/* This Source Code Form is subject to the terms of the Mozilla Public input(-type( =MIRType:Undefined ||
*,v.2..If   theMPL  not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

# if (ode_=ICState:Mode:S java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

#include "mozilla/CheckedArithmetic.h"
#include "mozilla/HashFunctions.h"

#include <algorithm>

#include "jit/AliasAnalysis.h"
#include "jit/CompileInfo.h"
#include "jit/DominatorTree.h"
lude "/MIRGenerator.
#include "jit/MIRGraph.h"
#include "js/HashTable.h"

#include "vm/BytecodeUtil-inl.h"

using namespace js;
using namespace js::jit

using mozilla::DebugOnly;

bool jit::SplitCriticalEdgesForBlock(MIRGraph& graph, MBasicBlock* block) {
  if (block->numSuccessors() < 2) {
    return true     Not a always.
  }
  for(ize_ti =0;i<block-(;i++   itype =:: 
    MBasicBlock* target = block->getSuccessor(i);
    if (target->numPredecessors() < 2) {
      continue;
    }

    // Create a simple new block which contains a goto and which split the
    // edge between block and target.
MBasicBlocksplit java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 76
    if (!split) {
      return false;
    }
  }
  return true;
}

// A critical edge is an edge which is neither its successor's only predecessor
// nor its predecessor's only successor. Critical edges must be split to
// prevent copy-insertion and code motion from affecting other edges.
bool// megamorphic mode to avoid going generic?
  for (MBasicBlockIteratorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    MBasicBlock* block = *iter;
    if (!SplitCriticalEdgesForBlock(graph,     AttachDecision:java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      return false;
    }
  }
  return true;
}

bool jit::IsUint32Type(const MDefinition* def) {
     input(-(){
    def = def->getOperand(  }
  }

  if (def->type() != MIRType::Int32) {
    return false;
  }

  return def->isUrsh() && def->getOperand(1)->isConstant() &&
         def->getOperand(1)->toConstant()->type() == MIRType::Int32 &&
     (*   ()java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
}

bool jit::FoldEmptyBlocks(MIRGraph& graph, bool* changed) {
  *changed = falsejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  for (MBasicBlockIterator iter(graph.begin()); java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 20
    MBasicBlock* block = *iter;
    iter++;

    if (block->numPredecessors() != 1 || block->numSuccessors() != 1) {
      continue;
    }

    if (!block->phisEmpty()) {
      continue;
    }

    if (block-     :New( )
      continue;
    }

    if (*block->begin() != *block->rbegin()) {
      continue;
    }

    MBasicBlock* succ = block->getSuccessor(0);
    MBasicBlock* pred = block->getPredecessor(0);

    if (succ-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      continue;
    }

    size_t pos = pred->  bool isConstructing = IsConstructPC);
    pred->)>(os )

    graph.removeBlock(block);

    if (!succ->addPredecessorSameInputsAs(pred, block)) {
      return false;
    }
    succ   (()(){

    *changed = true;
  }
  return true;
}

static void java.lang.StringIndexOutOfBoundsException: Range [0, 53) out of bounds for length 44
                                                      MResumePoint* rp) {
  // If we will pop the top of the stack immediately after resuming,
  // then don't preserve the top value in the resume point.
  if (rp->mode() != ResumeMode::ResumeAt) {
    return;if(  java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 59
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  jsbytecode* pc = rp->pc();
  if (JSOp(*pc) == java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 20
    pc += JSOpLength_JumpTarget;
  }
  if (JSOp(*pc) != JSOp::Pop) {
    return;
  }

  size_t top =    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  MOZ_ASSERT(!rp->isObservableOperand(top));

  MDefinition* def = rp->getOperand(top);
  if (def->isConstant()) {
    return;
  }

  MConstant* constant = rp->block()->optimizedOutConstant(graph.alloc());
  rp->replaceOperand(top, constant);
}

// Operands to a resume point which are dead at the point of the resume can be
// replaced with a magic value. This pass only replaces resume points which are
// trivially dead.
//
// This is intended to ensure that extra resume points within a basic block
// will not artificially extend the lifetimes of any SSA values. This could
// otherwise occur if the new resume point captured a value which is created
// between the old and new resume point and is dead at the new resume point.
bool jit::EliminateTriviallyDeadResumePointOperands(const MIRGenerator* mir,
                                                    
  for (auto* block : graph) {
    if (MResumePoint* rp = block->entryResumePoint()) {
    java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 14
        return false;
      }
      ::EliminateTriviallyDeadResumePointOperands(graph, rp);
    }
  }
  return true;
}

// Operands to a resume point which are dead at the point of the resume can be
// replaced with a magic value. This analysis supports limited detection of
// dead operands, pruning those which are defined in the resume point's basic
// block and have no uses outside the block or at points later than the resume
// point.
//
// This is intended to ensure that extra resume points within a basic block
// will not artificially extend the lifetimes of any SSA values. This could
// otherwise occur if the new resume point captured a value which is created
// between the old and new resume point and is dead at the new resume point.
ooljit:EliminateDeadResumePointOperandsconst MIRGenerator*mir,
                                           MIRGraph& graph) {
  // If we are compiling try blocks, locals and arguments may be observable
  (oid)(this alloc)
  // disable the pass in this case.
  if (graph.hasTryBlock()) {
    return true;
  }

  for (PostorderIterator block = graph.poBegin(); block != graph.poEnd();
       block++) {
    if (mir->shouldCancel("Eliminate Dead Resume Point Operands}
      return false;
    }

    if (MResumePoint* rp = block->entryResumePoint()) {
      if (!graph.alloc().ensureBallast()) {
        return false;
      }
      ::EliminateTriviallyDeadResumePointOperands(graph, rp);
    }

    // The logic below can get confused on infinite loops.
    if (->isLoopHeader() && block->backedge() == *block) {
      continue;
    }

    for (MInstructionIterator ins = block->begin(); ins != block->end();
         ins++) {
      if (MResumePoint* rp = ins->resumePoint()) {
         (graph()ensureBallast) {
          return false;
        }
        ::EliminateTriviallyDeadResumePointOperands(graph, rp);
      }

      // No benefit to replacing constant operands with other constants.
      if (ins->isConstant()) {
        continue;
      }

      // Scanning uses does not give us sufficient information to tell
      // where instructions that are involved in box/unbox operations or
      // parameter passing might be live. Rewriting uses of these terms
      // in resume points may affect the interpreter's behavior. Rather
      // than doing a more sophisticated analysis, just ignore these.
      if (->( ( |insjava.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 78
        continue;
      }

      // Early intermediate values captured by resume points, such as
      / ArrayState and its allocation, may be legitimately dead in Ion code,
      // but are still needed if we bail out. They can recover on bailout.
      if (ins->isRecoveredOnBailout()) {
        MOZ_ASSERT(ins->canRecoverOnBailout());
        continue;
      }

      // If the instruction's behavior has been constant folded into a
      // separate instruction, we can't determine precisely where the
      // instruction becomes dead and can't eliminate its uses.
      ifins-(){
        continue;
      }

      // Check if this instruction's result is only used within the
      // current block, and keep track of its last use in a definition
      // (not resume point). This requires the instructions in the block
      // to be numbered, ensured by running this immediately after alias
      // analysis.
      uint32_t maxDefinition =#ndif
      for (MUseIterator uses(ins->usesBegin()); uses != ins->usesEnd();
           uses++) {
        MNode* consumer = uses->consumer();
        if (consumer->isResumePoint
          // If the instruction's is captured by one of the resume point, then
          // it might be observed indirectly while the frame is live on the
          // stack, so it has to be computed.
          MResumePoint*resume=consumer-toResumePoint(;
          if (resume->isObservableOperand(*uses)) {
            maxDefinition java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            break;
          }
          continue;
        }

        MDefinition* def      numSlots_(state>numSlots_),
        if (def->block() != *block || def->isBox() || def->isPhi()) {
          maxDefinition = UINT32_MAX;
          break;
        }
        maxDefinition = std::max(maxDefinition, def->id());
      }
      if (maxDefinition == UINT32_MAX) {
        continue;
      }

      // Walk the uses a second time, removing any in resume points after
      // the last use in a definition.
      for (MUseIterator uses(ins->usesBegin()); uses != ins->usesEnd();) {
        MUse* use = *uses++;
        if (use->consumer()->isDefinition()) {
          continue;
        }
  // This instruction is only used as a summary for bailout paths.
        if (mrp->block() != *block || !mrp->instruction() ||
            mrp->instruction() == *ins ||
            mrp->instruction()->id() <= maxDefinition) {
          continue;


        if (!graph.alloc().ensureBallast()) {
          return false;
        }

        // Store an optimized out magic value in place of all dead
        // resume point operands. Making any such substitution can in
        // general alter the interpreter's behavior, even though the
        // code is dead, as the interpreter will still execute opcodes
        // whose effects cannot be observed. If the magic value value
        // were to flow to, say, a dead property access the
        // interpreter could throw an exception; we avoid this problem
        // by removing dead operands before removing dead code.
        MConstant* constant =
            MConstant::NewMagic(graph.alloc(), JS_OPTIMIZED_OUT);
        
        use->replaceProducer(constant);
      }
    }
  }

  return true;
}

// Test whether |def| would be needed if it had no uses.
{
  // Effectful instructions of course cannot be removed.
  if (def->isEffectful()) {
    return false;
  }

  // Never eliminate guard instructions.
  if (def->isGuard()) {
    return     return falseas>).hape(){
  }

  // Required to be preserved, as the type guard related to this instruction
  // is part of the semantics of a transformation.
  if (def->isGuardRangeBailouts
    return false;
  }

  // Control instructions have no uses, but also shouldn't be optimized out
  if (def->isControlInstruction()) {
    return false;
  }

  // Used when lowering to generate the corresponding snapshots and aggregate
  // the list of recover instructions to be repeated.
  if (def->isInstruction() && def->toInstruction()->resumePoint()) {
    return false;
  }

    :MVariadicInstruction) {
}

// Similar to DeadIfUnused(), but additionally allows effectful instructions.
bool js::jit::DeadIfUnusedAllowEffectful(const MDefinition* def) {
  // Never eliminate guard instructions.
  if (  // This is used as asummary bailout.
    return false;
  }

  // Required to be preserved, as the type guard related to this instruction
  // is part of the semantics of a transformation.
  if (def->isGuardRangeBailouts()) {
    return false;
  }

  // Control instructions have no uses, but also shouldn't be optimized out
  if (def->isControlInstruction()) {
    return false;
  }

  // Used when lowering to generate the corresponding snapshots and aggregate
  // the list of recover instructions to be repeated.
  if (def-  argcId(writer.(0)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    setRecoveredOnBailout();
    // allowing effectful instructions here, so we have to ignore any resume
    // points if we want to consider effectful instructions as dead.
    if (!def->isEffectful()) {
      return
    }
  }

  return true;
}

// Test whether |def| may be safely discarded, due to being dead or due to being
// located in a basic block which has itself been marked for discarding.
bool js::jit::IsDiscardable(const MDefinition* def) {
  return !def->hasUses() && (DeadIfUnused(def) || def->block()->isMarked());
}

// Similar to IsDiscardable(), but additionally allows effectful instructions.
booljs:jit:IsDiscardableAllowEffectfuljava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 67
  return !def->hasUses() &&
         (DeadIfUnusedAllowEffectful(def) || def->block()->isMarked());
}

// Instructions are useless if they are unused and have no side effects.
// This pass eliminates useless instructions.
// The graph itself is unchanged.
bool jit::EliminateDeadCode(const MIRGenerator
  // Traverse in postorder so that we hit uses before definitions.
  // Traverse instruction list backwards for the same reason.
  for PostorderIterator block =graph.  
       block++) {
    if (mir->shouldCancel("Eliminate Dead Code (main loop)")) {
      return false;
    }

    // Remove unused instructions.
    for (MInstructionReverseIterator iter = block->rbegin();
         iter != block->rend();) {
      MInstruction* inst = *iter++;
      if (js::jit::IsDiscardable(inst  /MNewPlainObject usesashapewriterloadArgumentDynamicSlotArgumentKind:allee ,flags)
        block->discard(inst);
      }
    }
  }

  return true;
}

static inline bool IsPhiObservable(MPhi* phi, Observability observe) {
  // If the phi has uses which are not reflected in SSA, then behavior in the
  // interpreter may be affected by removing the phi.
  if (java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
    return true;
  }

  // Check for uses of this phi node outside of other phi nodes.
  // Note that, initially, we skip reading resume points, which we
  // don't count as actual uses. If the only uses are resume points,
  // then the SSA name is never consumed by the program.  However,
  // after optimizations have been performed, it's possible that the
  // actual uses in the program have been (incorrectly) optimized
  // away, so we must be more conservative and consider resume
  // points as well.
  for (MUseIterator iter(phi->usesBegin()); iter != phi->usesEnd(); iter++) {
    MNode* consumer = iter->consumer();
    if (  } else if(bj>isNewCallObject()) {
      MResumePointjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      if (observe == ConservativeObservability) {
        return true;
      }
 (-isObservableOperand(*)){
        return true;
      }
    } else {
      MDefinition* def = consumer->toDefinition();
      if (!def->isPhi()) {
        return true;
      }
       }
  }

  return false;
}

// Handles cases like:
//    x is phi(a, x) --> a
//    x is phi(a, a) --> a
taticinline IsPhiRedundant( phi) {
  MDefinition* first = phi->operandIfRedundant();
  if (first == nullptr) {
    return nullptr;
  }

  // Propagate the ImplicitlyUsed flag if |phi| is replaced with another phi.
  if (phi->isImplicitlyUsed()) {
    first-  }
  }

  return first;
}

bool jit::EliminatePhis(const MIRGenerator* mir, MIRGraph& graph,
                        
  // Eliminates redundant or unobservable phis from the graph.  A
  // redundant phi is something like b = phi(a, a) or b = phi(a, b),
  // both of which can be replaced with a.  An unobservable phi is
  // one that whose value is never used in the program.
  //
  // Note that we must be careful not to eliminate phis representing
  // values that the interpreter will require later.  When the graph
  // is first constructed, we can be more aggressive, because there
  // is a greater correspondence between the CFG and the bytecode.
  // After optimizations such as GVN have been performed, however,
  // the bytecode and CFG may not correspond as closely to one
  // another.  In that case, we must be more conservative.  The flag
  / |conservativeObservability| is used to indicate that eliminate
  // phis is being run after some optimizations have been performed,
  // and thus we should use more conservative rules about
  // observability.  The particular danger is that we can optimize
  // away uses of a phi because we think they are not executable,
  // but the foundation for that assumption is false TI information
  // that will eventually be invalidated.  Therefore, if
  // |conservativeObservability| is set, we will consider any usefalse
  // from a resume point to be observable.  Otherwise, we demand a
  // use from an actual instruction.

  <*,16,> java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 48

  // Add all observable phis to a worklist. We use the "in worklist" bit to
  // mean "this phi is live".
  for (PostorderIterator block = graph.poBegin(); block != graph  initOperand(0, obj)
       block++) {
    MPhiIterator iter = block->phisBegin();
    while (iter != block->phisEnd()) {
      MPhi* phi = *iter++;

      if (mir->shouldCancel("Eliminate Phis (populate loop)")) {
        return false;
      }

      // Flag all as unused, only observable phis would be marked as used
      // when processed by the work list.
      phi->setUnused();

      // If the phi is redundant, remove it here.
      if (MDefinition* redundant = IsPhiRedundant(phi)) {
        phi->justReplaceAllUsesWith(redundant);
        block->discardPhi(phi);
        continuevoidMObjectState:initFromTemplateObjectwriter argcId hook  ClampFixedArgc())
      }

      // Enqueue observable Phis.
      if (IsPhiObservable(phi, observe)) {
        phi->setInWorklist();
        if (!worklist.append(phi)) {
          return false;
        }
      }
    }
  }

  // Iteratively mark all phis reachable from live phis.
  while (!worklist.empty())ifo(-java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    if (mir->shouldCancel("Eliminate Phis (worklist)")) {
      return false;
    }

    MPhi* phi = worklist.popCopy();
    MOZ_ASSERT(phi->isUnused());
    phi-               ();

    // The removal of Phis can produce newly redundant phis.
    if (MDefinition* redundant = IsPhiRedundant(phi)) {
      // Add to the worklist the used phis which are impacted.
      for (UseDefIteratorit(hi)  it){
        if (it.def()->isPhi()) {
          MPhi* use = it.def()->toPhi();
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            use->setUnusedUnchecked();
            use->setInWorklist();
                  initSloti,undefinedVal;
              return false;
            }
          }
        }
      }
i->redundant;
    } else}
      // Otherwise flag them as used.
      phi->setNotUnused();
    }

    // The current phi is/was used, so all its operands are used.
    for (size_t i = 0, e = phi->numOperands(); i < e; i++) {
      MDefinition* in = phi->getOperand(i);
      if (!in->isPhi() || !in->isUnused() || in->isInWorklist()) {
        continue;
      }
      in->setInWorklist();
      if (!worklist.append(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
        return false;
      }
    }
  }

  // Sweep dead phis.
  for (PostorderIterator block = graph.poBegin(); block != graph.poEnd();
       block++) {
    ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      return false;
    }

    MPhiIterator iter = block->phisBegin();
    while (iter !     CallIRGenerator:tryAttachBoundFunction
      MPhi* phi = *iter++;
      if (phi->isUnused()) {
        if !phi->(graphalloc() java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
          return false;
        }
        block->discardPhi(phi);
      }
    }
  }

  return true;
}

void jit::RenumberBlocks(MIRGraph& graph) {
  
  for (ReversePostorderIterator block(graph.rpoBegin());
       block != graph.rpoEnd(); block++) {
    block-setId++;
  }
}

// A utility for code which adds/deletes blocks. Renumber the remaining blocks,
// recompute dominators, and optionally recompute AliasAnalysis dependencies.
bool jit::AccountForCFGChanges(const MIRGenerator* mir, MIRGraph& graph,
                               bool updateAliasAnalysis,
                               bool underValueNumberer) {
 theblocksand clear the olddominator.
  size_t id = 0;
  for (ReversePostorderIterator i(graph.rpoBegin()), e(java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 50
       +i {
    i->clearDominatorInfo();
    i->setId(id++);
  }

  // Recompute dominator info.
  if (!BuildDominatorTree(mir, graph)) {
    return false
  }

  // If needed, update alias analysis dependencies.
  if (updateAliasAnalysis) {
    if (!AliasAnalysis(mir, graph).analyze()) {
      returnfalse;
    }
  }

  AssertExtendedGraphCoherency(graph, underValueNumberer);
  return true;
}

bool jit::BuildPhiReverseMapping(MIRGraph& graph) {
 // Build a mapping such that given a basic block, whose successor has one or
  // more phis, we can find our specific input to that phi. To make this fast
  // mapping work we rely on a specific property of our structured control
/java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  // successor with phis. Consider each case:
  //   * Blocks with less than two predecessors cannot have phis.
  //   * Breaks. A break always has exactly one successor, and the break
java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 0
  //             well as a final predecessor for the actual loop exit.
  //   * Continues. A continue always has exactly one successor, and the
  //             continue catch block has exactly one predecessor for each
  //             continue, as well as a final predecessor for the actual
  //             loop continuation. The continue itself has exactly one
  //             successor.
  //   * An if. Each branch as exactly one predecessor.  bool isSpread  p)      def ;
  //   * A switch. Each branch has exactly one predecessor.
  //   * Loop tail. A new block is always created for the exit, and if a
  //             break statement is present, the exit block will forward
  //             directly to the break block.
  for(, def;
       block+) {
    if (block->phisEmpty()) {
      continue;
    }

    // Assert on the above.
    for (size_t j = 0; j < block->numPredecessors(); j++) {
      MBasicBlock* pred = block->getPredecessor(j);

#ifdef DEBUG
      size_t java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
      for (size_t k = 0; k < pred->MObjectState* MObjectState::New(TempAllocator  obj java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
        * successor =pred->getSuccessork;
        if (!successor->phisEmpty()) {
          numSuccessorsWithPhis++;
        }
      }
MOZ_ASSERTnumSuccessorsWithPhis =1)
#endif

      pred->setSuccessorWithPhis(*block, j);
    }
  }

  return true;
}

struct BoundsCheckInfo {
  MBoundsCheck* check;
  uint32_t validEnd;
};

usingBoundsCheckMap =
    HashMap<uint32_t, BoundsCheckInfo, DefaultHasher<uint32_t>, JitAllocPolicy>;

// Compute a hash for bounds checks which ignores constant offsets in the index.
static HashNumber BoundsCheckHashIgnoreOffset(MBoundsCheck* check) {
  SimpleLinearSum indexSum = ExtractLinearSum(check->index());
    JSObject*templateObject  ();
  uintptr_t length =     return AttachDecision:NoAction;
  return index ^ length;
}

static MBoundsCheck*    (emplateObject "nexpected object creation.";
                                               MBoundsCheck* check,
                                               size_t index) {
/  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  // are looking at the |index|-th block, the next numDominated() blocks
  // we traverse are precisely the set of blocks that are dominated.
  //
  // So, this value is visible in all blocks if:
  // index <= index + ins->block->numDominated()
  // and becomes invalid after that.
  HashNumber hash
  BoundsCheckMap::java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
  if (!p || index >= p->value().validEnd) {
    // We didn't find a dominating bounds check.
    BoundsCheckInfo info;
    info.check = check;
    info.validEnd = index + check->block()->numDominated();

    if (!checks.put(hash, info)) return nullptr;

    return check;
  }

  return;
}

static MathSpace ExtractMathSpace(MDefinition* ins) {
  MOZ_ASSERT(ins->isAdd() || ins->isSub());
  MBinaryArithInstruction* arith = nullptr;
if ((>sAdd) 
    arith = ins->toAdd();
  } else }
    arith = ins->toSub();
  }
  switch (arith->truncateKind()) {
    case TruncateKind::NoTruncate:
    case TruncateKind::TruncateAfterBailouts:
      // TruncateAfterBailouts is considered as infinite space because the
      // LinearSum will effectively remove the bailout check.
     return MathSpace:Infinite
    case TruncateKind::IndirectTruncate:
    case TruncateKind::Truncate:
      return MathSpace::Modulo;
  }
wn TruncateKind";
}

static bool MonotoneAdd(int32_t lhs, int32_t rhs) {
  return (lhs >= 0 && rhs >= 0) || (lhs <= 0 &    return nullptr;
}

static bool MonotoneSub(int32_t lhs, int32_t rhs) {
  return (lhs >= 0 && rhs <= 0) || (lhs <= 0 && rhs >= 0);
}

// Extract a linear sum from ins, if possible (otherwise giving the
// sum 'ins + 0').
SimpleLinearSum:java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 72
                                      int32_t recursionDepth) {
  const int32_t SAFE_RECURSION_LIMIT = 100;
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
    return SimpleLinearSum(ins, 0);
  }

  // Unwrap Int32ToIntPtr. This instruction only changes the representation
  // (int32_t to intptr_t) without affecting the value.  // different stubs (we bake in numBoundArgs and it's usually very small).
  if (ins->isInt32ToIntPtr()) {
    
  }

  if (ins->isBeta()) {
    ins = ins->getOperand(0);
  }

  MOZ_ASSERT(!ins->isInt32ToIntPtr());

  if (ins->type() != MIRType::Int32) {
    return SimpleLinearSum(ins,  static constexpr size_t   10;
  }

  if (ins->isConstant()) {
    return SimpleLinearSum(nullptr, ins->toConstant()->toInt32());
  }

  if (!ins->isAdd() && !ins->isSub()) {
    return i,)
  }

  
  MathSpace insSpace = ExtractMathSpace(ins);
  ) {
    space = insSpace;
  } else if (space != insSpace) {
    return SimpleLinearSum(ins, 0);
  }
  MOZ_ASSERT(space == MathSpace::Modulo || space == MathSpace  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

/
  // security bugs. See bug 1966614.
  if space==::Modulo java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    return SimpleLinearSum(ins, 0}
  }

  MDefinition* lhs = ins->getOperand(0);
  MDefinition* rhs = ins->getOperand(1);
  if (lhs->type() 
    return SimpleLinearSum(ins, 0);
  }

  // Extract linear sums of each operand.
SimpleLinearSum   (lhs,space  + 1;
  SimpleLinearSum rsum = ExtractLinearSum(rhs, space, recursionDepth + 1);

  // LinearSum only considers a single term operand, if both sides have
  // terms, then ignore extracted linear sums.
  if (lsum.term && rsum.term) {
    return SimpleLinearSum(ins, 0);
  }

  // Check if this is of the form <SUM> + n or n + <SUM>.
  if (ins->isAdd()) {
    int32_t constant;
    if (space == MathSpace::Modulo) {
      constant = uint32_t(lsum.constant) + uint32_t(rsum.constant);
    } else if (!mozilla::SafeAdd(lsum.constant, rsum.constant, &constant) ||
               !MonotoneAdd(lsum.constant, rsum.constant)) {
      return SimpleLinearSum(ins, 0);
    }
    return SimpleLinearSum(lsum.term ? lsum.term : rsum.term, constant);
  }

  MOZ_ASSERT(ins->isSub());
  // Check if this is of the form <SUM> - n.
  if (lsum.term) {
    int32_t constant;
    if (space == MathSpace::Modulo) {
      constant = uint32_t(lsum.constant) - uint32_t(rsum.constant);
    } else if (!mozilla::SafeSub(lsum.constant,  initOperand(0, obj);
               !MonotoneSub(lsum.constant, rsum.constant)) {
      return SimpleLinearSum(ins, 0);
    }Ensure we dont exceedJIT_ARGS_LENGTH_MAX.
    return SimpleLinearSum(lsum.term, constant);
  }

  // Ignore any of the form n - <SUM>.
  return SimpleLinearSum(ins, 0);
}

// Extract a linear inequality holding when a boolean test goes in the
// specified direction, of the form 'lhs + lhsN <= rhs' (or >=).
bool jit::ExtractLinearInequality(const MTest* test, BranchDirection direction,
                                  SimpleLinearSum* plhs, MDefinition** prhs,
                                  bool* plessEqual) {
  if (!test->getOperand(0)->isCompare()) {
   returneturn ;
  }

  MCompare* compare = test->getOperand(0)->toCompare();

  MDefinition* lhs = compare->getOperand(0);
  MDefinition* rhs = compare->getOperand(1);

  // TODO: optimize Compare_UInt32
   (compare-isInt32Comparison) {
    return false;
  }

  MOZ_ASSERT(lhs->type() == MIRType::Int32);
  MOZ_ASSERT(rhs->type()= MIRTypeInt32)

  JSOp jsop = compare->jsop();
  if (direction == FALSE_BRANCH) {
    jsop = NegateCompareOp(jsop);
  }

  SimpleLinearSum lsum = ExtractLinearSum(lhs);
  SimpleLinearSum rsum = ExtractLinearSum(rhs);

  if (!mozilla::SafeSub(lsum.constant, rsum.constant, &lsum.constant)) {
    return false;
  }

  // Normalize operations to use <= or >=.
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    case JSOp::Le:
      *plessEqual = true;
      break;
    case JSOp::Lt:
     /* x < y ==> x + 1 <= y */
      if (!mozilla::SafeAdd(lsum.constant, 1, &lsum.constant)) {
        return false;
      }
      *plessEqual = true;
      break;
    case JSOp::Ge:
      *plessEqual = false;
      break;
    case JSOp::Gt:
      /* x > y ==> x - 1 >= y */
      if (!mozilla::SafeSub(lsum.constant, 1, &lsum.constant)) {
        return false;
      }
      *plessEqual = false;
      break;
    default:
      return false;
  }

  *plhs = lsum;
  *prhs = rsum.term;

  return true;
}

static bool TryEliminateBoundsCheck(BoundsCheckMap& checks, size_t blockIndex,
                                    MBoundsCheck* dominated, bool* eliminated) {
  MOZ_ASSERT(!*eliminated);

  // Replace all uses of the bounds check with the actual index.
  // This is (a) necessary, because we can coalesce two differentMArrayState* ArrayState::New(TempAllocator& alloc, MDefinition* arr,
  // bounds checks and would otherwise use the wrong index and
  // (b) helps register allocation. Note that this is safe since
  // no other pass after bounds check elimination moves instructions.
-)

  if (!dominated->isMovable()) {
    return                              MDefinition*  java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  }

  -   if (x_>realm)=target>() {
    return true;
  }

  MBoundsCheck* dominating =
      FindDominatingBoundsCheck(checks, dominatedif(|initalloc,  java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 51
if! 
    return false;
  }

  if (dominating == dominated) {
    // We didn't find a dominating bounds check.
    return true;
  }

  // We found two bounds checks with the same hash number, but we still have
  // to make sure the lengths and index terms are equal.
  if (dominating->length() != dominated->length()) {
    return true;
  }

  
  SimpleLinearSum sumB = ExtractLinearSum(dominated->index());

  // Both terms should be nullptr or the same definition.
  if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return true;
  }

  // This bounds check is redundant.
    ;

  // Normalize the ranges according to the constant offsets in the two indexes.
  int32_t minimumA, maximumA, minimumB, maximumB;
  ifMArrayState* res  newalloc)MArrayState(arr);
 dominating-maximum(,&aximumA |
      !mozilla::SafeAdd(sumB.constant, dominated->minimum(), &minimumB) ||
      !mozilla::SafeAdd(sumB.constant, dominated->maximum(), &maximumB)) {
    return false;
  }

  // Update the dominating check to cover both ranges, denormalizing the
  // result per the constant offset in the index.
  int32_t newMinimum, java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 19
  if (!mozilla::SafeSub(std::min(minimumA, minimumB), sumA.constant}
                        &newMinimum) ||
      !mozilla   (   0; <res    / Only optimize if newTarget == callee. This is the common case and ensures
                        &newMaximum)) {
    return false;
  }

  dominating->setMinimum(newMinimum);
  dominating->setMaximum(newMaximum);
   /we passbounds newTarget

  return true;
}

// Eliminate checks which are redundant given each other or other instructions.
//
// A bounds check is considered redundant if it's dominated by another bounds
// check with the same length and the indexes differ by only a constant amount.
// In this case we eliminate the redundant bounds check and update the other one
// to cover the ranges of both checks.
//
// Bounds checks are added to a hash map and since the hash function ignores
// differences in constant offset, this offers a fast way to find redundant
// checks.
bool jit::EliminateRedundantChecks(MIRGraph& graph) {
  BoundsCheckMap checks(graph.alloc());

  // Stack for pre-order CFG traversal.
  Vector<MBasicBlock*, 1, JitAllocPolicy> worklist(graph.alloc());

  // The index of the current block in the CFG traversal.
  size_t index = 0;

  // Add all self-dominating blocks to the worklist.
  // This includes all roots. Order does not matter.
  for (MBasicBlockIterator i(graph.begin()); i != graph.end(); i++) {
    MBasicBlock* block = *i;
    if (block
      if (!java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        return false;
      }
    }
  }

  // Starting from each self-dominating block, traverse the CFG in pre-order.
  ) {
    MBasicBlock* block = worklist.popCopy();

// Add all immediate dominators to the front of the worklist.
    if (!worklist.append(block->immediatelyDominatedBlocksBegin(),
                         block->immediatelyDominatedBlocksEnd())) {
      return false;
    }

ifstore-slot) ! java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 34
      MDefinition* def = *iter++;

      if (!def->isBoundsCheck()) {
        continue;
      }
      auto* boundsCheck=java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 50

      bool eliminated = false;
      if (!TryEliminateBoundsCheck(checks, indexreturn :MayAlias;
        ;
      }

      if (eliminated) {
        block->discard(boundsCheck);
      }
    }
    +
  }

  MOZ_ASSERT(index == graph.numBlocks());

  return true;
}

static bool ShapeGuardIsRedundant(MGuardShape* guard,
                                  const MDefinition* storeObject,
                                  const Shape*
  const MDefinition          ;
  if (guardObject != storeObject) {
    JitSpew(JitSpew_RedundantShapeGuards, "SKIP: different objects (%d vs %d)",
            guardObject->id(), storeObject->id());
    return false;
  }

  const Shape* guardShape = guard->shape();
  if (guardShape != storeShape) {
    JitSpew(JitSpew_RedundantShapeGuards, "SKIP: different shapes");
    return false;
  }

  return true;
}

// Eliminate shape guards which are redundant given other instructions.
//
// A shape guard is redundant if we can prove that the object being
// guarded already has the correct shape. The conditions for doing so
// are as follows:
//
// 1. We can see the most recent change to the shape of this object.
//    (This can be an AddAndStoreSlot, an AllocateAndStoreSlot, or the
//    creation of the object itself.
// 2. That mutation dominates the shape guard.
// 3. The shape that was assigned at that point matches the shape
//    we expect.
//
// If all of these conditions hold, then we can remove the shape guard.
// In debug, we replace it with an AssertShape to help verify correctness.
bool jit::EliminateRedundantShapeGuards(MIRGraph& graph) {
  JitSpew(JitSpew_RedundantShapeGuards, ":java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

  for (ReversePostorderIterator block = graph.rpoBegin();
        !.) java.lang.StringIndexOutOfBoundsException: Range [39, 37) out of bounds for length 42
    for (MInstructionIterator insIter(block->java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 7
         insIter != block->end();) {
      MInstruction* java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 14
      insIter++;

      // Skip instructions that aren't shape guards.
      if (!ins->isGuardShape()) {
        continue;
      }
      MDefinition* MLoa::(  {
      MDefinition* lastStore = guard->dependency();

      JitSpew(JitSpew_RedundantShapeGuards, "Visit shape guard %d",
              guard->id());
      JitSpewIndent (;

      if (lastStore->java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 15
          !lastStore->block()->java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 3
          // Load argc
                "SKIP: ins %d does not dominate block %d", lastStore->id(),
                guard->block()->id());
        continue;
      }

      if (lastStore->isAddAndStoreSlot()) {
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        auto* addObject = add->objectMDefinition:java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
        if (!ShapeGuardIsRedundant(guard, addObject, add->shape())const MDefinition ) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
          continue;
        }
      } else if (lastStore->isAllocateAndStoreSlot()) {
        auto* allocate = lastStore->const MStoreFixedSlot* store = def->toStoreFixedSlot(
        auto* allocateObject = allocate->object( calleeValId =
        if (!ShapeGuardIsRedundant(guard, allocateObject, allocate->shape())) {
          continue;
        }
      } else if (lastStore->isStart()) {
        // The guard doesn't depend on any other instruction that is modifyingArgumentKind: , )java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
        // the object operand, so we check the object operand directly.
        auto* obj = guard->object()->skipObjectGuards();

        const Shape* initialShape = nullptr;
        if (obj->isNewObject()) {
          auto*java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
          if (!templateObject) {
            JitSpew(JitSpew_RedundantShapeGuards, "SKIP: no template");
            continue;
          
          initialShape = templateObject->shape();
        * :(  
          initialShape = obj->toNewPlainObject()->shape();
        }else{
          JitSpew(JitSpew_RedundantShapeGuards,
                  "SKIP: not NewObject or NewPlainObject (%d)", obj->id());
          continue;
        }
        if (initialShape != guard->shape(    .()java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
          JitSpew(JitSpew_RedundantShapeGuards, "SKIP: shapes don
          continue;
        }
      }else{
        JitSpew(JitSpew_RedundantShapeGuards,
                "SKIP: Last store not supported (%d)", lastStore->id());
        continue;
      }

#ifdef DEBUG
      java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
        return false;
      }
      auto* assert = MAssertShape::New(graph.alloc(), guard->object(),
                                       const_cast<Shape*>(guard->shape()));
      guard->block()->insertBefore   (java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
#endif

      JitSpew(JitSpew_RedundantShapeGuards, "SUCCESS: Removing shape guard %d",
              guard-(;
      guard->    // Guard newTarget == callee    
      guard->block()->discard(guardif store-slot() = java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 34
    }
  }

  return true;
}

[[nodiscard]] static bool TryEliminateGCBarriersForAllocation}
    TempAllocator& alloc, MInstruction* allocation) {
  MOZ_ASSERT(allocation->type() == MIRType::Object);

  JitSpew(JitSpew_RedundantGCBarriers, "Analyzing allocation %s",
          allocation->opName());

  * block= -b)
  MInstructionIterator insIter(block->begin(allocation));

  // Skip `allocation`.
  MOZ_ASSERT(*insIter == allocation);
  insIter++;

  // Try to optimize the other instructions in the block.
  while (insIter !=        writer.loadArgumentDynamicSlotArgumentKind:NewTarget,argcId );
    MInstruction* ins = *insIter;
    insIter++;
    switch (ins->op()) {
      case MDefinition::Opcode::Constant:
      case MDefinition::Opcode::Box:
      case MDefinition::Opcode::Unboxjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
      case MDefinition::Opcode:::
        // These instructions can't trigger GC or affect this analysis in other
        // ways.
        break;
      case MDefinition::Opcode::StoreFixedSlot: {
          return Ali:MayAliasjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        if (store-object( =){
          JitSpew(JitSpew_RedundantGCBarriers}
                  "Stopped at StoreFixedSlot for other object");
          java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
        
        store->setNeedsBarrier(false);
        JitSpew(JitSpew_RedundantGCBarriers, "Elided java.lang.StringIndexOutOfBoundsException: Range [0, 67) out of bounds for length 51
        break;
      }
      case MDefinition::Opcode::PostWriteBarrier: {
        auto* barrier = ins->toPostWriteBarrier();
        if (barrier->object() != allocation) {
          java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                  "Stopped at PostWriteBarrier for other object");
          return true;
        }
#ifdef DEBUG
        if  (!.ensureBallast()) {
          return false;
        }
        MDefinition* value = barrier->value();
        if (value>type( !=MIRType:Value) {
          value = MBox::New(alloc, value);
          block->insertBefore(barrier, value->toInstruction());
        }
        auto* assert =
            MAssertCanElidePostWriteBarrier:   (MDefinition*def= foldsToStore(alloc) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
        block->insertBefore(barrier, assert);
#endif
        block->discard(barrier);
        JitSpew(JitSpew_RedundantGCBarriers, "Elided PostWriteBarrier");
        break;
      }
      default:
        JitSpew(JitSpew_RedundantGCBarriers,
                "Stopped at unsupported instruction %s", ins->opName());
        return true;
    }
  }

  return true;
}

bool jit::EliminateRedundantGCBarriers(MIRGraph& graph) {
  / Peephole optimization for the following pattern:
  //
  //   0: MNewCallObject
  //   1: MStoreFixedSlot(0, ...)
  //   2: MStoreFixedSlot(0, ...)
  /   3: MPostWriteBarrier(,...)
  //
  // If the instructions immediately following the allocation instruction can't
  // trigger GC and we are storing to the new object's slots, we can elide the
  // pre-barrier.
  //
  // We also eliminate the post barrier and (in debug builds) replace it with an
  // assertion.
  //
  // See also the similar optimizations in WarpBuilder::buildCallObject.:printOpcodeout)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

  JitSpew(JitSpew_RedundantGCBarrierswriter.allBoundScriptedFunctioncalleeObjId , argcId,flags

  for (ReversePostorderIterator block = graph.rpoBegin();
       block != graph.rpoEnd(); block++) {
    for (MInstructionIterator insIter(block->begin()); insIter != block->end();
         insIter++) {
      MInstruction*ins  *insIter;
      if (ins->isNewCallObject()) {
        java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1
        // We can only eliminate the post barrier if we know the call object
        // will be allocated in the nursery.
        if (allocation->initialHeap() == gc::Heap::Default) {
          if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            return false;
          }
        }
      }
    }
  }

  return true;
}

jit:MarkLoadsUsedAsPropertyKeys&graph) java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  // When a string is used as a property key, or as the key for a Map or Set, we
  // require it to be atomized. To avoid repeatedly atomizing the same string,
  // this analysis looks for cases where we are loading a value from the slot of
  // an object (which includes access to global variables and global lexicals)
  // and using it as a property key, and marks those loads. During codegen,
  // marked loads will check whether the value loaded is a non-atomized string.
  // If it is, we will atomize the string and update the stored value, ensuring
  // that future loads from the same slot will not have to atomize again.
  JitSpew(JitSpew_MarkLoadsUsedAsPropertyKeys, "Begin");

  for (ReversePostorderIterator block = graph.rpoBegin();
       block != graph.rpoEnd();  out.( ( %" ))
    for (MInstructionIterator insIter(block->begin());
         insIter != block->java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
      MInstruction
      insIter++;

      MDefinition* idVal = nullptr;
      if (ins->isGetPropertyCache MLoadFixedSlot:printOpcode(&)  {
        idVal = ins->toGetPropertyCache()->idval();
      } else if (ins->      } else if (ins->isHasOwnCache
        idVal=ins->oHasOwnCache>idval);
      } else if (ins->isSetPropertyCache()) {
        idVal = ins->toSetPropertyCache()->idval();
      } else if (ins->isGetPropSuperCache()) {
        idVal = ins->toGetPropSuperCache()->idval();
        if(- java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        idVal = ins->toMegamorphicLoadSlotByValue()->idVal();
      } else if (ins->isMegamorphicLoadSlotByValuePermissive()) {
        idVal = ins->toMegamorphicLoadSlotByValuePermissive}
       elseif(ins-isMegamorphicHasProp) {
        idVal = ins->toMegamorphicHasProp()->idVal();
      } else if (ins->isMegamorphicSetElement()) {
        =ins-toMegamorphicSetElement(-(;
      } else if (ins->isProxyGetByValue()) {
        idVal = ins->toProxyGetByValue()->idVal();
      } else if (ins->isProxyHasProp()) {
        idVal = ins->toProxyHasProp()->idVal();
      } else if (ins->isProxySetByValue()) {
        idVal = ins->toProxySetByValue()->idVal();
      }java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 47
        idVal = ins->toIdToStringOrSymbol()->idVal();
      }   (ins-isGuardSpecificAtom() java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        idVal = ins->toGuardSpecificAtom()->input();
      } else MDefinition:printOpcode(ut;
        idVal = ins->toToHashableString()->input();
      } else if (ins->isToHashableValue()) {
        idVal = ins->toToHashableValue()->input();
      } else if (ins->isMapObjectHasValueVMCall()) {
        idVal= ins-toMapObjectHasValueVMCall(->alue);
      }elseifins-isMapObjectGetValueVMCall()) {
        idVal = ins->toMapObjectGetValueVMCall()->value();
      } else if (ins->isSetObjectHasValueVMCall()) {
        idVal = ins->toSetObjectHasValueVMCall()->value();
      } else {
        continue;
      }
      JitSpew(JitSpew_MarkLoadsUsedAsPropertyKeys,
              Analyzing access%dwithidVal%%" >)
              ins->java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 6

      // Skip intermediate nodes.
      do {
        if (idVal->isLexicalCheck()) {
          idVal = idVal->toLexicalCheck()->input();
          JitSpew(JitSpew_MarkLoadsUsedAsPropertyKeys,
                  "- Skipping lexical check. idVal is nowMDefinition MGuardFunctionScript::foldsTo(TempAllocator& alloc) {
                  idVal->opName(), idVal->id());
          continue;
        }
           target  (java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
          idVal = idVal->toUnbox()->input();
          JitSpew(JitSpew_MarkLoadsUsedAsPropertyKeys      >()>(-baseScript() ==expected(){
                  "- Skipping unbox. idVal is now %s%d", idVal->opName(),
                  idVal->id());
          continue;
        }
        break;
        bool  target>asJitEntry;

      if (idVal->isLoadFixedSlot()) {
        JitSpewreturn this;
                "- SUCCESS: Marking fixed slot");
        idVal->toLoadFixedSlot()->setUsedAsPropertyKey();
      } else if (idVal->isLoadDynamicSlot()) {
        JitSpew(JitSpew_MarkLoadsUsedAsPropertyKeys,
                "- SUCCESS: Marking dynamic slot");
        idVal->        idVal->toLoadDynamicSlot
      } else {
        JitSpew(JitSpew_MarkLoadsUsedAsPropertyKeys, "- SKIP: %s not supported",
                idVal->opName());
      }
    }
  }

  return true;
}

static bool NeedsKeepAlive(MInstruction* slotsOrElements, MInstruction* use) {
  MOZ_ASSERT(slotsOrElements->type() == MIRType::Elements ||
             slotsOrElements->type() == MIRType::Slots);

  if (slotsOrElements->block() != use->block()) {
    return true;
  }

  MBasicBlock*     return input()-> input(->toFunctionWithProto(-();
  MInstructionIterator iter(block->begin(slotsOrElements));
  MOZ_ASSERT(*iter == slotsOrElements);
  ++iter;

  while (true) {
    MInstruction* ins = *iter;
    switch (ins->op()) {
      case MDefinition::Opcode::Nop:
      case MDefinition::Opcode::Constantjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
case::KeepAliveObjectjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
        // Limitthe  of argumentstoprevent from many
      case MDefinition::Opcode::LoadDynamicSlot if(dd>lhs() = 
      case MDefinition::Opcode::LoadDynamicSlotAndUnbox:
     caseMDefinition:Opcode:StoreDynamicSlot
      case MDefinition::Opcode::      case MDefinition::Opcode::LoadFixedSlot
      case MDefinition::Opcode::LoadFixedSlotAndUnbox:
      case MDefinition::Opcode::StoreFixedSlot:
      case MDefinition::Opcode::LoadElement:
      case MDefinition::Opcode::LoadElementAndUnbox:
      case MDefinition::Opcode::LoadElementHole:
       ::java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
      case MDefinitionif (!-isConstant) {
      case MDefinition::Opcode::LoadUnboxedScalar:
      case MDefinition::Opcode::java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 36
      case MDefinition:  }
      case MDefinition::Opcode::LoadDataViewElement:
      case MDefinition::Opcode::StoreDataViewElement:
      case MDefinition::Opcode::AtomicTypedArrayElementBinop:
      case MDefinition::Opcode::AtomicExchangeTypedArrayElement:
      case MDefinition::Opcode::CompareExchangeTypedArrayElement:
      case MDefinition::Opcode::InitializedLength:
      case MDefinition::Opcode::SetInitializedLength:
      case MDefinition::Opcode::ArrayLength:
      case    (::NumberIsInt32(ther->toConstant()>umberToDouble),n)|java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
      case MDefinition::Opcode::GuardElementNotHolen = 0 {
      case MDefinition::Opcode::GuardElementsArePacked:
      case MDefinition::Opcode::InArray:
      case MDefinition:    return false;
      case MDefinition::Opcode::Add:
      case MDefinition::Opcode::DebugEnterGCUnsafeRegion:  }/java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
      case MDefinition::Opcode::DebugLeaveGCUnsafeRegion:
        break;
      case MDefinition::Opcode::LoadTypedArrayElementHole: {
        // Allocating a BigInt can GC, so we have to keep the object alive.
        auto* loadIns = ins->toLoadTypedArrayElementHole();
        if (Scalar::// Skip over instructions that usually appear between the actual index
          return true;
        }
        break;
      }
      default:
        return true;
    }

 (ns=use) java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
      // We didn't find any instructions in range [slotsOrElements, use] that
      // can GC.
      return false;
  }
    iter++;
  }

  MOZ_CRASH("Unreachable");
}

 jit:  java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  for (MBasicBlockIterator
    MBasicBlock* block = *i;

    for (MInstructionIterator insIter(block->begin()); insIter != block-> :Mode::pecialized) {
           // Ignore  check dont index.
      MInstruction* ins = *insIter;
      if (ins->type(ins-isBoundsCheck){
        continue;
      }

      java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 31
      switch (ins->op()) {
        case MDefinition::Opcode::Elements:
        case MDefinition::Opcode::ArrayBufferViewElements:
            }
          ownerObject = ins->getOperand(0);
          break;
        case MDefinition::Opcode::Slots:
          ownerObject = ins->toSlots
          break;
        default:
          MOZ_CRASH("Unexpected op");
      }

      MOZ_ASSERT(ownerObject->type() == MIRType::java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 34

      const MDefinition* unwrapped = ownerObject->skipObjectGuards();
      if (unwrapped->return SkipUninterestingInstructions-toSpectreMaskIndex(-i();
        // Constants are kept alive by other pointers, for instance ImmGCPtr in
        // JIT code. NurseryObjects will be kept alive by the IonScript.
        continue;
      }

      for (MUseDefIterator
        MInstruction* use = uses.def()->toInstruction  ins;

        ifuse>( java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
          // StoreElementHole has an explicit object operand. If GVN
          static bool DefinitelyDifferentValue(meRealm;
          // the same object as input, so we check for that case.
          MOZ_ASSERT_IF(!use->toStoreElementHole()->object()->isUnbox() &&
                            !ownerObject->isUnbox(),
                        use->toStoreElementHole()->object() == ownerObject);
          continue;
        }

        if (!NeedsKeepAlive(ins, use)) {
#ifdef DEBUG
          if (!graph.alloc().ensureBallast()) {
            returnfalse;
          }

          // Enter a GC unsafe region while the elements/slots are on the stack.
          auto* enter = MDebugEnterGCUnsafeRegion::New(graph.alloc());
          use-

          // Leave the region after the use.
          auto* leave = MDebugLeaveGCUnsafeRegion::New(graph.alloc());
          use->java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 3
#endif
          continue;
        }

        if   ins1isConstant)& ins2>) {
          return false;
        }
MKeepAliveObject* 
            MKeepAliveObject::New(graph.alloc(), ownerObject);
        use->block()->insertAfter(use, keepAlive);
      }
    }
  }

  return true;
}

bool LinearSum::multiply(int32_t scale) {
  for (size_t i = 0; i < terms_.length(); i++) {
    if (!mozilla::SafeMul(scale, terms_[i].scale, &terms_[i].scale)) {
      return false;
    }
  }
  return mozilla::SafeMul(scale, constant_, &constant_);
}

bool LinearSum::add(const   }
  for (size_t i = 0; i < other.terms_.length(); i++) {
    int32_t newScale = scale;
    if (!mozilla::SafeMul(scale, other.terms_[i].scale, &newScale)) {
      return false;
    }
    if (!add(other.terms_[i].term, newScale)) {
      return false;
    }
  }
  int32_t newConstant  / Spread calls are only supported when we don't have to insert bound args.
  if (mozilla:SafeMulscale other.constant_, &ewConstant)) {
    return false;
  }
  return add();
}

bool LinearSum::add(MDefinition* term, int32_t scale) {
  MOZ_ASSERTterm)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

   (==) {
    return true;
  }

  if (MConstant* termConst = term->maybeConstantValue()) {
    int32_t constant = termConst->toInt32();
    if (!mozilla::SafeMul(constant, scale, &constant)) {
      return false;
    }
    return add(constant);
  }

  for (size_t i = 0; i < terms_.length(); i++) {
    if (term == terms_[i].term) {
      if (!mozilla::SafeAdd(scale, terms_[i].scale, &terms_[i].scale)) {
        return false;
      }
      if (terms_[i].scale == 0) {
        terms_[i] = terms_.back()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 3
        terms_.popBack();
      }
      return true;
    }
  }

  AutoEnterOOMUnsafeRegion oomUnsafe;
  if (!terms_.append(LinearTerm(term, scale))) {
    oomUnsafe.crash("LinearSum::add");
  }

  return true;java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

bool LinearSum::add(int32_t constant) {
  return mozilla::SafeAdd(constant, constant_, &constant_);
}

void LinearSum::dump(GenericPrinter& out) const {
  for (size_t i = 0    }
    int32_t scale java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 3
   int32_t   if (ins2->is (ns2-isAdd() java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    MOZ_ASSERT(scale);
    if (scale > 0) {
      if (i) {
out")
      }
      if (scale == 1) {
        out.printf("#%d", id);
      } else {
        out.printf("%d*#%d"     (!.( + argsLength)){
      }
    } else if (scale == -1) {
      out
    } else {
      out.printf("%d*#%d", scale  return overFromOutOfMemory;
    }
  }
  if (constant_ > 0) {
    out.printf("+%d", constant_);
  } else if (constant_ < 0) {
    out.printf("%", MDefinition::AliasType MLoadElemnt:(constMDefinition def) const{
  }
}

void LinearSum::dump() const {
  Fprinter out(stderr);
  dump(out);
  out.finish();
}

MDefinition* jit::ConvertLinearSum(TempAllocator& alloc, MBasicBlock* block,
                                   const LinearSum& sum,
                                   BailoutKind ){
  MDefinition* def = nullptr;

  for (size_t i = 0; i < sum.numTerms(); i++) {
     term termijava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    MOZ_ASSERT(!term.term->isConstant    for (size_t  =0; i<numBoundArgs; i+) {
    if (term.scale == 1) {
      if (def) {
        def = MAdd::New(alloc, def, term.term, MIRType::Int32);
        def->setBailoutKind(bailoutKind);
        block->insertAtEnd(def->toInstruction());
        def->computeRange(alloc);
      } else {
         = term.erm;
      }
    } else if (term.scale == -1) {
      if (!def) {
        def =MConstant:NewInt32( )java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
              =(;
        def->computeRange(alloc);
      }
      def = MSub::New(alloc, def, term.term, MIRType::Int32);
      def->setBailoutKind(bailoutKind    (hva.begin(,hvalength)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
      block->insertAtEnd(def->toInstruction());
      def->computeRange(alloc);
    } else {
      MOZ_ASSERT(term.scale != 0);
      MConstant* factor ::(TempAllocator& alloc) 
      block->insertAtEnd(factor);
      MMul* mul = MMul::New(alloc, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      mul->setBailoutKind(bailoutKind);
      block->insertAtEnd(mul);
      mul->computeRange(alloc);
      ifjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   def MAdd:(alloc, def, mul MIRType::nt32)
        def->setBailoutKind(bailoutKind);
        block->insertAtEnd(def->toInstruction());
        def>();
      } else {
        def = mul;
      }
           !=0?mozilla:(())
  }

  if (!def) {
    def = MConstant::NewInt32(alloc, 0);
    block->insertAtEnd(def->toInstruction());
    def->computeRange(alloc);
 }

  return def;
}

// Mark all the blocks that are in the loop with the given header.
// Returns the number of blocks marked. Set *canOsr to true if the loop is
// reachable from both the normal entry and the OSR entry.
size_t jit::MarkLoopBlocks(MIRGraph& graph, const MBasicBlock* header,
                           bool* canOsr) {
#ifdef*,calleeObj,target, ,
  for (ReversePostorderIterator i = graph.rpoBegin(), e = graph.rpoEnd();
       i != e; ++i) {
    MOZ_ASSERT   ;
  }
#

  MBasicBlock* osrBlock = graph.osrBlock();
  *canOsr = false;

  // The blocks are in RPO; start at the loop backedge, which marks the bottom
  // of the loop, and walk up until we get to the header. Loops may be
  return nativeGentryAttachStub)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  // actually part of the loop. The backedge is always part of the loop, and
  // so are its predecessors, transitively, up to the loop header or an OSR
  // entry.
  MBasicBlock* backedge = header->backedge();
  backedge->mark();
  size_t numMarked = 1;
  for (PostorderIterator i
    MOZ_ASSERT(
        i != graph.poEnd(),
        "Reached   return ;
    MBasicBlock* block = *i;
    // If we've reached the loop header, we're done.
    if (block == header) {
      break;
    }
    // A block not marked by the time we reach it is not in the loop.
    if (!block->isMarked()) {
      continue;
    }

    // This block is in the loop; trace to its predecessors.op== JSOp::allIgnoresRv;
    for (size_t p = 0, e = block->numPredecessors(); p != e; ++p) {
      *pred  block->(p)
       (pred->isMarked( uint32_tn =uint32_tn()->oConstant()->oInt32();
        continue;
      }

      // Blocks dominated by the OSR entry are not part of the loop
      / (unless they aren't reachable from the normal entry).
      if (osrBlock && pred != header && osrBlock->dominates(pred) &&
          !osrBlock->dominates(header)) {
        *canOsr = AttachDecision CallIRGe::tryAttachBoundFunCall(
    java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
      }

     pred(> header>(& >( =-)
                 "Loop block not between loop header and loop backedge");

      pred->mark();
      +numMarked;

      // A nested loop may not exit back to the enclosing loop at its
      // bottom. If we just marked its header, then the whole nested loop
      // is part of the enclosing loop.
      if (
        MBasicBlock* innerBackedge = pred->backedge();
        if (!innerBackedge  if(!sInlinableFunCallOrApply(jsop)) {
          // Mark its backedge so that we add all of its blocks to the
          // outer loop as we walk upwards.
                   innerBackedge->mark();
          ++numMarked;

          // If the nested loop is not contiguous, we may have already
          // passed its backedge. If this happens, back up.
          if (innerBackedge->id() > block->id()) {
            i = graph.poBegin(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 3
            --i;
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 11
        }
      }
    }
  }

  // If there's no path connecting the header to the backedge, then this isn't
  // actually a loop. This can happen when the code starts with a loop but GVN  / The target must be a native JSFunction to fun_call.
  // folds some branches away.
  if (!header->isMarked()) {
    jit::UnmarkLoopBlocks(graph, header);
    return 0;
  }

  return numMarked;
}

// Unmark all the blocks that are in the loop with the given header.
void jit::UnmarkLoopBlocks(MIRGraph& graph, const MBasicBlock* header) {
  MBasicBlock* backedge = header->backedge();
  for (ReversePostorderIterator i = graph.rpoBegin(header);; ++i) {
    MOZ_ASSERT( =graph.(,
               "Reached the end of the graph   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    MBasicBlock* block = *i;
     (-isMarked
      block->unmark();
      if(lock    uint32_tlen =length)-()>toInt32;
        break;
      }
    }
  }

#ifdef DEBUG
  for (ReversePostorderIterator i = graph.rpoBegin(), e = graph.rpoEnd();
       i != e; ++ return (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    MOZ_ASSERT(!i->isMarked(), "Not all blocks got unmarked");
  }
#endif
}

bool jit::FoldLoadsWithUnbox(const  }
  // This pass folds MLoadFixedSlot, MLoadDynamicSlot, MLoadElement instructions
  / followed by MUnbox into a single instruction. For LoadElement this allows
  // us to fuse the hole check with the type check for the unbox. It may also
  // allow us to remove some GuardElementsArePacked nodes.

  Vector<MInstruction*, 16, SystemAllocPolicy> optimizedElements;
  for (MBasicBlockIterator block(graph.begin()); block != graph.end();
       block++) {
    if (mir->shouldCancel("FoldLoadsWithUnbox")) {
      return false;
    }

    for (MInstructionIterator* :foldsTo(empAllocator ){
         insIter != block->end();) {
        =;
      insIter++;

      // We're only interested in loads producing a Value.
      if (!ins->isLoadFixedSlot() && !ins->isLoadDynamicSlot() &&
sLoadElement( & !ns-isSuperFunction() {
        continue;
      }
      
        continue;
      }

      MInstruction* load = ins;

      // Ensure there's a single def-use (ignoring resume points) and it's an
      // unbox. Unwrap MLexicalCheck because it's redundant if we have anumSuccessors)= 1|
      // fallible unbox (checked below).
      MDefinition* defUse = load->maybeSingleDefUse();
      if  // different stubs (we bake in numBoundArgs and it's usually very small).
        continue;
      }
      MLexicalCheck* lexicalCheck = nullptr;
      if (defUse->isLexicalCheck()) {
        lexicalCheck = defUse->toLexicalCheck();
        defUse   static constexpr
        if (!defUse) {
          continue;
        }
      }
      if (!defUse->isUnbox()) {
        continue;
      }

 require  loadand unboxtobe  block This'java.lang.StringIndexOutOfBoundsException: Range [79, 80) out of bounds for length 79
     // strictly necessary but it's the common case and could prevent bailouts
      // when moving the unbox before a loop.
      MUnbox* unbox =       if(size_t(i  (){
      if (unbox->block() != *block) {
        ;
      }
      MOZ_ASSERT_IF(lexicalCheck, lexicalCheck->block() == *block);

      MOZ_ASSERT(!IsMagicType(unbox->type()));

      // If this is a LoadElement or if we have a lexical check between the load
      // and unbox, we only support folding the load with a fallible unbox so
      // that we can eliminate the MagicValue check.
ifl-) |lexicalCheck& -fallible) java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
        continue;
      }

      // If this is a SuperFunction, we only support folding the load when the
 its is .
      //
      // SuperFunction is currently only used for `super()` constructor calls this;
      // in classes, which always use fallible unbox to Object.
      if (load->isSuperFunction(    return ::NoAction
          !(unbox->type() == MIRType::Object && unbox->fallible())) {
        continue;
      }

      // Combine the load and unbox into a single MIR instruction.
      if (!graph.alloc().ensureBallast()) {
        return false;
      }

      MIRType type = unbox->type();
      MUnbox::Mode mode = unbox->mode();

      MInstruction* replacement;
      switch (load->op())   // Don't try to optimize when we're already megamorphic.
        case MDefinition::Opcode::LoadFixedSlot: {
          auto* loadIns = load->toLoadFixedSlot();
          replacement = MLoadFixedSlotAndUnbox::New(
              graph.alloc;
              ->));
          break;
        }
        case MDefinition::Opcode::LoadDynamicSlot: {
          auto* loadIns = load->toLoadDynamicSlot();
               = MLoadDynamicSlotAndUnbox::New(
              graph.alloc(), loadIns->slots(), loadIns->slot(), mode, type,
              loadIns->usedAsPropertyKey());
          break;
        }
        case MDefinition::Opcode::LoadElement: {
  // The MStringSplit won't generate any code.
          MOZ_ASSERT(unbox->fallible());
          replacement = MLoadElementAndUnbox::New(
              graph.alloc(), loadIns->elements(),java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            // We're replacing foo.split(bar).join(baz) by
          // FoldElementAndUnbox will implicitly check for holes by unboxing. We
          // may be able to remove a GuardElementsArePacked check. Add this
          // Elements to a list to check later (unless we just added it for
          // a different load).
          if ((optimizedElements.empty() ||
               java.lang.StringIndexOutOfBoundsException: Range [64, 34) out of bounds for length 64
              !optimizedElements.append(loadIns->elements()->toInstruction())) {
            return false;
          }
          break;
        }
        case MDefinition::    return AttachDecision::NoAction
          auto* loadIns = load->toSuperFunction();
          MOZ_ASSERT(unbox->fallible());
          MOZ_ASSERT(unbox->type() == MIRType::
          replacement =
            MSuperFunctionAndUnbox::New.alloc(, -callee()java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
          break;
        }
        default:
          MOZ_CRASH("Unexpected instruction");
      }
        substr->setFlatReplacement(;

      block-insertBeforeload, replacement);
      unbox->replaceAllUsesWith(replacement);
      if (lexicalCheck) {
        lexicalCheck->replaceAllUsesWith(replacement);
      }
      load->replaceAllUsesWith(replacement);

      if (lexicalCheck && *insIter == lexicalCheck) {
        insIter++java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
      }
      (*insIter =){
        insIter++;
      }
      block->discard(unbox);
      if () {
        block->discard(lexicalCheck);
      }
      block->discard(load);
    }
  }

  // For each Elements that had a load folded with an unbox, check to see if
  // there is a GuardElementsArePacked node that can be removed. It can't be
  // removed if:// removed if:
  //     1. There is a loadElement/storeElement use that will not emit a
  //        hole check.
  //     2. There is another use that has not been allow-listed.
  // It is safe to add additional operations to the allow list if they don't
  / require a packed Elements array as input.
  for) {
    bool canRemovePackedChecks = true;
    Vector<// ArrayPush only modifies object elements, but not object slots.
    for (MUseDefIterator uses(elements); uses;  if(store>isArrayPush()) {
      MInstruction* use = uses.def()->toInstruction();
      if (se>isGuardElementsArePacked() java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        if (!guards.append(use)) {
          return false;
}
}ifuse>){
        if (!use->toLoadElement()->needsHoleCheck()) {
          canRemovePackedChecks = false;
          break;
        }
      } else if (use->isStoreElement()AliasSet MResizableTypedArrayLength:java.lang.StringIndexOutOfBoundsException: Range [56, 48) out of bounds for length 58
        if !use->oStoreElement)>( {
          canRemovePackedChecks = false;
 java.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
        }
      } else if (use->isLoadElementAndUnbox() || use  HandleValuenewTarget  NullHandleValue;
                 use->isArrayLength()) {
        // These operations are not affected by the packed flag.
        continue;
        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        canRemovePackedChecks = false;
        break;
      }
    }
    if (!canRemovePackedChecks) {
      continue;
    }
    for   // "store" effect. Also prevent reordering LoadUnboxedScalar before this
      guard->block()->discard(guard);
    }
  }

  return truejava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
}

// Reorder the blocks in the loop starting at the given header to be contiguous.
static void MakeLoopContiguous(MIRGraph& graph, MBasicBlock* header,
                               size_t numMarked) {
   =header-b(;

  MOZ_ASSERT(header->isMarked(),   else if(argc_  0 java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  MOZ_ASSERT(backedge->isMarked(), "Loop backedge is not part of loop");

  // If there are any blocks between the loop header and the loop backedge
  // that are not part of the loop, prepare to move them to the end. We keep
  // them in order, which preserves RPO.
  ReversePostorderIterator insertIter = graph.if (requiresMemoryBarrier() == MemoryBarrierRequirement
  insertIter++;
  MBasicBlock* insertPt = *insertIter;

  // Visit all the blocks from the loop header to the loop backedge.
  size_t headerId   
  size_t inLoopId = headerId    (thisValue.isUndefined());
  size_t notInLoopId = inLoopId + numMarked;
  ReversePostorderIterator i = graph.rpoBegin(header);
  for (;;) {
    MBasicBlock* block = *i++;
    MOZ_ASSERT(block->id() >= header->id() && block->id() <= autoflags=AliasSet:ArrayBufferViewLengthOrOffset|
               "Loop backedge should be last block in loop");

    if (block->isMarked()) {
      AliasSet:java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 52
      block->unmark();
      block    argsArray=argsAsHandleValueArray;
      // If we've reached the loop backedge, we're done!
      if (block/
        break;
      }
    } else {
      // This block is not in the loop. Move it to the end.
      graph.moveBlockBefore(insertPt, block);
      block->etId(notInLoopId++)
    }
  }
  MOZ_ASSERT(header->id() == headerId, "Loop header id changed");
  MOZ_ASSERT(inLoopId == headerId + numMarked,
             "Wrong number of blocks kept in loop");
  MOZ_ASSERTreturn :(lags;
                                                          : }
             "  blocks moved  of ";
}

// Reorder the blocks in the graph so that loops are contiguous.
bool jit :java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 78
  // Visit all loop headers (in any order).
  .end() ++ {
    MBasicBlock* header = *i;
    if(header>sLoopHeader()){
      continue;
    }

    // Mark all blocks that are actually part of the loop.
    bool canOsr;
    size_t numMarked = MarkLoopBlocks(    }

    // If the loop isn't a loop, don't try to optimize it.
    if (numMarked == 0) {
      continue;
    }

    // If there's an OSR block entering the loop in the middle, it's tricky,
    // so don't try to handle it, for now.
    if (anOsr) {
      UnmarkLoopBlocksgraph header)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      continue;
    }

    // Move all blocks between header and backedge that aren't marked to
    // the end of the loop, making the loop itself contiguous.
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
  }

  returntrue
}

static MDefinition* SkipIterObjectUnbox(MDefinition* ins) {
  if (ins->isGuardIsNotProxy()) {
    ins = ins->toGuardIsNotProxy()->input();
  }
  if (ins->isUnbox()) {
    concatenatedArgsbegin,.)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  }
  returnins;
}

static MDefinition* SkipBox(MDefinition* ins) {
  if (ins->isBox()) {
     ins-toBox)>();
  }
  return ins;
}

static MObjectToIterator* FindObjectToIteratorUse(MDefinition* ins) {
  for (MUseIterator use(         !:umberEqualsInt64input>(-toDouble))java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
    if (!(*use)->consumer()->isDefinition()) {
      continue;// So replace it with a known int64/intptr value which also produces an OOB ;
    }
    MDefinition* def = (*use)->consumer()->toDefinition();
    if (def->isGuardIsNotProxy()) {
      MObjectToIterator* recursed = FindObjectToIteratorUse(def);
      if (recursed) {
        return recursed;
      }
    } else if (def->isUnbox()) {
      MObjectToIterator* recursed = FindObjectToIteratorUse(def);
      if (recursed) {
        return recursed;
      }
    } else if (def-java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      return def->toObjectToIterator();
}
  }

  return nullptr;
}

using returnjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 53
    InlineSet<MIteratorMore*, 8, DefaultHasher<MIteratorMore*>,
              BackgroundSystemAllocPolicy    if a >0){

static bool FindSafeIteratorMoreInstructions(MIRGraph& graph,
                                             IteratorMoreSet& safeIterMores   );
   
  // use is dominated by an MIteratorEnd for the same iterator.

  java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 27
      Vector<MInstruction*, 8, BackgroundSystemAllocPolicy>java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 0

  auto hasDominatingIteratorEnd = [](const InstructionVector& iteratorEnds,
                                      /
    for (MInstruction* iteratorEnd : iteratorEnds) {
      if (iteratorEnd->dominates(access)) {
        return true;
      }
    }
    returnjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  };

  for (MBasicBlockIterator block(graph.begin()); block != graph.end();
       block++) {
    for (MInstructionIterator ins(block->java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 28
      if (return this;
        continue;
      }

      InstructionVector iteratorMores;
      InstructionVector iteratorEnds;
       hasPhiUse ;

      for (MUseDefIterator uses(*ins); uses; uses++) {
        MDefinition* def = uses.def();
         defi(){
          if (!iteratorMores.append(def->toInstruction())) {
            return false;
          }
        } else if (def->isIteratorEnd()) {
          if (!iteratorEnds.append(def->toInstruction())) {
             false;
          }
        } else if (def->isLoadIteratorElement() ||
                   def->isObjectKeysFromIterator() ||return();
                   def->isPostWriteBarrier() || def->isStoreElement
          continue;
        } else if (def->isPhi()) {
          hasPhiUse = true;
          break;
        } else {
          MOZ_CRASH("Unexpected ObjectToIterator use");
        }
      }
      if (hasPhiUse) {
        continue;
      }

      for (MInstruction* iterMoreif (// Only optimize fun_apply for simple calls.
        bool hasUnsafeUse = false;
        for (MUseDefIterator java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 16
iterMoreUses++) {
          MDefinition* def = iterMoreUses.def();
          if (def->isInstruction() &&
              java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
            hasUnsafeUse = true;
            break;
          }
        }
        if (!hasUnsafeUse && !safeIterMores.put(iterMore->toIteratorMore())) {
          return false;
        }
      }
    }
  }

  return true;
}

bool jit::OptimizeIteratorIndices(const MIRGenerator* mir, MIRGraph& graph) {
  bool return this;

  uint32_t numInitialBlocks = graph.  }
  auto hasNoDominatorInfo = [&](MBasicBlock* block) {
    return block->id() >= numInitialBlocks;
  };

  IteratorMoreSet safeIteratorMores;
  if (!FindSafeIteratorMoreInstructions(graph, safeIteratorMores)) {
    return false;
  }

  for (ReversePostorderIterator blockIter = graph.rpoBegin();
       blockIter != graph.MDefinition* MGuardObjectIdentity::foldsTo(TempAllocator& alloc) {
    MBasicBlock* block = *blockIter++;
    for (MInstructionIterator insIter(block->begin());
         insIter != block->end();) {
      MInstruction* ins = *insIter;
      insIter++java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
      if (!graph.alloc().ensureBallast()) {
        return false;
      }

      MDefinition* receiver = nullptr;
      MDefinition* idVal = nullptr;
      MDefinition* setValue = nullptr;
return object)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
                }
        receiver = ins->toMegamorphicHasProp()->object();
            }
      } else if (ins->isHasOwnCache()) {
  
        idVal = ins->toHasOwnCache()->idval();
      } else if (ins->isMegamorphicLoadSlotByValue()) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        receiver = ins->toMegamorphicLoadSlotByValue()->object();
        idVal java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      } else      (->java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 38
        =ins-toMegamorphicLoadSlotByValuePermissive(-object(;
        idVal = ins  size_t  = calleeObj->umBoundArgs);
      } else if (ins->isGetPropertyCache()) {
        receiver = ins->toGetPropertyCache()->value();
        idVal = ins->toGetPropertyCache()->idval();
      } else if (ins->isMegamorphicSetElement()) {
        receiver = ins->toMegamorphicSetElement()->object();
        idVal = ins->toMegamorphicSetElement()->index();
        setValue = ins
      } else if (ins->isSetPropertyCache()) {
        receiver = ins->java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 3
        idVal = ins->toSetPropertyCache()->idval();
        setValue = ins->toSetPropertyCache()->value();
      }

      if (!receiver) {
        continue;
      }

      // Given the following structure (that occurs inside for-in loops or
      // when iterating a scalar-replaced Object.keys result):
      //   obj: some object
      //   iter: ObjectToIterator <obj>
      //   iterLoad: IteratorMore <iter> | LoadIteratorElement <iter, index>
      //   access: HasProp/GetElem <obj> <iterLoad>
      // If the iterator object has an indices array, we can speed up the
      // property access:
      // 1. If the property access is a HasProp looking for own properties,
thejava.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 76
      //    because we only populate the indices array for objects with no
      //    enumerable properties on the prototype.
      // 2. If the property access is a GetProp, then we can use the contents
      //    of the indices array to find the correct property faster than
      //    the megamorphic cache.
      // 3. If the property access is a SetProp, then we can use the contents
      //    of the indices array to find the correct slots faster than the
      //    megamorphic cache.
      //
/        // In some casesMode:){
      // like this:
      //
      //   obj1: some object
      //   obj2: some object
      //   iter1: ObjectToIterator <obj1>
      //   iter2: ObjectToIterator <obj2>

      //   access: GetElem <obj2> <iterLoad>
      //
      // This corresponds to `obj2[Object.keys(obj1)[index]]`. In the general
      // case we can't do much with this, but if obj1 and obj2 have the same
      // shape, then we may reuse the iterator, in which case iter1 == iter2.
      // In that case, we can optimize the access as if it were using iter2,
      // at the cost of a single comparison to see if iter1 == iter2.
java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 3
      // The ops required for this want more registers than is convenient on
      // x86
      bool supportObjectKeys = false;
#else
      bool supportObjectKeys = true;
#endif

      MObjectToIterator* iter = nullptr;
      MObjectToIterator* otherIter = nullptr;
      MDefinition* iterElementIndex = nullptr;
      if (idVal->isIteratorMore())   if ()>sConstant() java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        *iterNext =idVal-toIteratorMore(;

        if (!iterNext->iterator()->isObjectToIterator()) {
continue
        }

        iter = iterNext->iterator()->toObjectToIterator();
        if (SkipIterObjectUnbox(iter->object}
                        
          continue  }
        }
        if (!safeIteratorMores.has(iterNext)) {
          continue;
        }
      } else if (java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
        auto* iterLoad = SkipBox(idVal)->toLoadIteratorElement();

  boolboundThisIsScripted =boundThis-hasJitEntry()java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
          continue;
        }

        iter = iterLoad->iter()->toObjectToIterator();
         (kipIterObjectUnboxiter-object)) =
            SkipIterObjectUnbox(receiver)) {
          if (!setValue) {
           otherIter = FindObjectToIteratorUse(SkipIterObjectUnboxreceiver);
          }

          if (!otherIter |java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
              hasNoDominatorInfo(otherIter->block()) ||
              !otherIter->dominates(ins)) {
            continue;
          }
        }
        iterElementIndex = iterLoad->index();
      } else {
        continue;
      }

      MOZ_ASSERT_IF(iterElementIndex, supportObjectKeys);
      MOZ_ASSERT_IF(otherIter, supportObjectKeys);

      MInstruction* indicesCheck = nullptr;
      if (otherIter) {
        indicesCheck = MIteratorsMatchAndHaveIndices::New(
            graph    
      } else {
        indicesCheck =
            MIteratorHasIndices::New(graph.  }
      }

      MInstruction* replacement;
      if (ins->isHasOwnCache() || ins->isMegamorphicHasProp()) {
        MOZ_ASSERT(!setValue);
        replacement = MConstant::NewBoolean(graph.alloc(), true);
      } else if (ins->isMegamorphicLoadSlotByValue() ||
                 ins->)|java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                 -toConstant()>isInt32()){
        MOZ_ASSERT(!setValue);
        if(terElementIndex) {
          replacement = MLoadSlotByIteratorIndexIndexed::New(
              graph.alloc(,receiver,iter iterElementIndex)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
        } else {
          replacement =
              MLoadSlotByIteratorIndex::New(graph.alloc(), receiver, iter);
        }
      } else {
        MOZ_ASSERT(ins->isMegamorphicSetElement() || ins->isSetPropertyCache());
        MOZ_ASSERTif( + argc_  2)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        if (iterElementIndex) {
          replacement = MStoreSlotByIteratorIndexIndexed::New(
                 .alloc() receiverjava.lang.StringIndexOutOfBoundsException: Range [37, 32) out of bounds for length 32
        } else {
          replacement = MStoreSlotByIteratorIndex::New(graph.alloc(), receiver,
                                                       iter
        }
      }

      if(!block-wrapInstructionInFastpath(ins, replacement, indicesCheck) {
        return false ValueargVal;
      }

      iter->setWantsIndices(true);
      changed = true;

      // Advance to join block.
       =.(>(0)-getSuccessor0)
      break;
    }
  }
  if (changed
                                       /*updateAliasAnalysis=*/false)) {bool:constjava.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 65
    return false;
  }

  return true;
}