Quelle  RegExpNativeMacroAssembler.cpp   Sprache: C

*+ :8:nil
 * vim MOZ_VTUNE
 *  Source CodeForm subject the  ofthe  Public
*,v ..If  of  MPL  distributed this
 * fileYou obtain  http//mozilla.org/MPL/2.0/. */
includejitjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
// Copyright 2020 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

# irregexpregexp-macro-assembler-arch
#include "irregexp/imported/regexp-stack masm_(masm)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
#include "irregexp/ MOZ_ASSERT(num_capture_registers_%2= )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
includejith
#include "jit/PerfSpewer.h"
#include "vm/MatchPairs.h"
#include "vm/Realm.h"
#ifdef MOZ_VTUNE
#  include "vtune/VTuneWrapper.h"
#endif

#include "jit/ABIFunctionList-inl.h"
#include "jit/MacroAssembler-inl.h"

namespace v8 {
namespace internal {

using js::MatchPairs;
using js::jit::AbsoluteAddress;
using js::jit::Address   =regs();
using::jit:;
usingjs:jit:;
using js::jit::BaseIndex;   = regs();
usingjs:::CodeLocationLabel;
 js:::;
using js:jitGeneralRegisterForwardIterator
using js::jit::GeneralRegisterSet;
using    
using jstemp2_.takeAny
usingjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
using js
ing:jitLinker
 :jitLiveGeneralRegisterSet
 :jit:Registerjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
using js::jit::RegistersreturnRegExpStackkStackLimitSlackSlotCount
 jsjit:StackMacroAssemblerjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

SMRegExpMacroAssembler::SMRegExpMacroAssembler(JSContext* cx,
                                               StackMacroAssembler& masm,
                                               
                                               uint32_t num_capture_registers( =0® )
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      cx_cx,
      masm_(masm  js:::Label;
      mode_),
      num_registers_/java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
      num_capture_registers_num_capture_registers java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
/  capturehas start and  endregister
  MOZ_ASSERT(num_capture_registers_ % 2 == 0                 (), &);

  AllocatableGeneralRegisterSet regs(GeneralRegisterSet::All// are interrupted, so we only check for urgent interrupts.

  input_end_pointer_ = regs.takeAny();
  current_character_ = regs.takeAny();
  current_position_  masm_.branchTest32
        Assembler::Zero(cx_-addressOfInterruptBits()
0 =regs();
  temp1_regstakeAny();
  if (!regs.empty()) {
    // Not enough registers on x86.
    temp2_ masm_();
}
  savedRegisters_ = js::jit:  .movePtr((js:egExpRunStatus:)) );

  masm_.jump(&entry_label_);  // We'll generate the entry code laterjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
.start_label_
}

int SMRegExpMacroAssembler.()
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

 :AdvanceCurrentPosition ) java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  if ::CheckAtStartImplint, *,
    masm_addPtr( *char_size) );
  }
}

void SMRegExpMacroAssembler::AdvanceRegister(int reg, int by) {
     addr, cp_offset *char_size();
   (by! ){
    masm_.addPtr(Imm32(by), register_location(reg));
  }
}

void  
#(cp_offset on_at_start,::Equal
  js
  // Check for simulating interrupt
masm_(Assembler:otEqualjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
AbsoluteAddress&>isolate-),
                 Imm32(0), &bailOut);
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  // Check for an interrupt. We have to restart from the beginning if we

void:(uint32_t,*on_equal 
  masm_.branchTest32(
     ::, (cx_-()),
      Imm32(uint32_t(js::InterruptReason::CallbackUrgent)), &noInterrupt);
#ifdef}
  
  void::CheckNotCharacteruint32_t c,
#endif
  masm_.movePtr(ImmWord(int32_t(js::RegExpRunStatus::Error)), temp0_);
  masm_.jump(&exit_label_                                               *on_not_equal){
  masm_(&noInterrupt;

  // Pop code offset from backtrack stack, add to code base address, and jump to
  // location.
  voidSMRegExpMacroAssembler:CheckCharacterGT(base:uc16,
  PushBacktrackCodeOffsetPatch(.movWithPatchImmPtr(), temp1_);
  masm_.addPtr(temp1_, temp0_);
  masm_.jump(temp0_);
}

id::BindLabellabel{
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  if (label->patchOffset_.bound()) {
el-patchOffset_ label-();
  }
}

// Check if current_position + cp_offset is the input start
 SMRegExpMacroAssembler( cp_offset Label,
                                              Assembler::Condition condjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
Address(current_position_  *())java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  masm_.computeEffectiveAddress(addr, temp0_);

  masm_.branchPtrLabel* on_cond,
}

void SMRegExpMacroAssembler::CheckAtStart(int cp_offset, Label* on_at_start) {
  CheckAtStartImplcp_offset,on_at_start AssemblerEqual;
}

void SMRegExpMacroAssembler::CheckNotAtStart(int cp_offset,
                                             :Conditioncond =is_not:: : Assembler:;
  CheckAtStartImpl,on_not_at_start,Assembler:);
}

void SMRegExpMacroAssembler::CheckCharacterImpl                       (on_cond;
                                                : cond{
ranch32condcurrent_character_c (on_cond;
}

void SMRegExpMacroAssembler::CheckCharacter(uint32_t c,    .branch32,temp0_ () (on_cond;
  CheckCharacterImpl(Imm32(c)  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

void SMRegExpMacroAssembler::CheckNotCharacter(uint32_t c,
                                               Label* on_equal){
    CheckCharacterAfterAndImplmaskon_equal,/*is_not =*/false);
}

voidvoid::CheckNotCharacterAfterAnd cjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                                              Label* on_greater) {
  CheckCharacterImpl(Imm32(limit), on_greater, Assembler::GreaterThan);
}

void                                                       *on_not_equal{
                                              Label  CheckCharacterAfterAndImplc , on_not_equal/*is_not =*/true);
  CheckCharacterImpl(Imm32// result with mask, then check SMRegExpMacroAssembler:heckNotCharacterAfterMinusAnd
}

// Bitwise-and the current character with mask and then check for a
// match with c.
void SMRegExpMacroAssembler::CheckCharacterAfterAndImpl(uint32_t c   ( =0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
                                                       
                                                        
                                                        java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  if (c == 0) {
    Assembler::Condition cond = is_not ? Assembler// stack, pops the backtrack stack and branches to the given label.
    masm_.branchTest32  ::::Label;
                       LabelOrBacktrack);
  } else {
    Assembler::Condition cond = is_not ? Assembler::NotEqual : Assembler::Equal;
masm_(Imm32),temp0_;
    masm_.and32(current_character_, temp0_);
    masm_.branch32(condmasm_(Imm32sizeof)) );  /Pop
  }
}

 SMRegExpMacroAssembler(
                                                    uc16, :: toLabel on_cond,Assembler: cond
  CheckCharacterAfterAndImpl(c, mask  .computeEffectiveAddress(current_character_ -),temp0_;
}

void SMRegExpMacroAssembler::CheckNotCharacterAfterAnd(uint32_t
uint32_t mask,
                                                       Label* on_not_equal) {
  CheckCharacterAfterAndImpl(c, mask,base:: to
}

// Subtract minus from the current character, then bitwise-and the
// result with mask, then check for a match with c.
void SMRegExpMacroAssembler::CheckNotCharacterAfterMinusAnd(CheckCharacterInRangeImpl, toon_in_rangeAssembler:);
voidSMRegExpMacroAssemblerCheckCharacterNotInRange:: from
  masm_computeEffectiveAddressAddresscurrent_character_ -minus),temp0_;
  if (c == 0) {
    masm_.branchTest32(Assembler::NonZero, temp0_, Imm32(mask),
                                                                             Label on_not_in_range
   else
    masm_.
    masm_.
/* static*java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  }
}

// If the current position matches the position stored on top of the backtrack
// stack, pops the backtrack stack and branches to the given label.
void SMRegExpMacroAssembler::CheckGreedyLoop(Label* on_equal) {
js:jit::Labelfallthrough
  masm_.load32SignExtendToPtruint32_tlength = ranges->length() / sizeof(uint16_t);
  masm_.branchPtr(Assembler::NotEqual, temp0_, current_position_, &fallthrough);
  masm_.addPtr(Imm32(sizeof(int32_t)), backtrack_stack_pointer_);  // Pop.
  JumpOrBacktrack(on_equal);
  masm_.ind(fallthrough;
}

voidSMRegExpMacroAssembler:CheckCharacterInRangeImpl(
    base:: from, base::uc16to, Label* on_cond, Assembler::Conditioncond {
  // x is in [from,to] if unsigned(x - from) <= to - from
  masm_.computeEffectiveAddress(Address(current_character_, -from    // It is not in the range array.
  masm_branch32(ond temp0_, Imm32(to- from) LabelOrBacktrackon_cond))java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
}

voidSMRegExpMacroAssembler:CheckCharacterInRange::uc16 fromjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
                                                   base    
                                                   * on_in_range {
  CheckCharacterInRangeImpl(from, to, on_in_range, Assembler::BelowOrEqual);
}

void
  / || is stored asan intervallist:  ordered of
                                                      Label* on_not_in_range) {
  CheckCharacterInRangeImpl(from,to, on_not_in_range, :);
}

/* static */
bool SMRegExpMacroAssembler::IsCharacterInRangeArray(uint32_t c,
                                                     . For
  js::AutoUnsafeCallWithABIunsafe
  MOZ_ASSERT(ranges->length() % sizeof(uint16_t) == 0);
  uint32_tlength = ranges-length() /sizeofuint16_t;
  MOZ_ASSERT(length > 0);

  // Fast paths.
  if (c < ranges->getTyped<uint16_t>(0)) {
    // |c| is lower than the start of the first range.  // every character would be represented as [0]).
    // It is not in the range array.
    return false;
  }
  // closest to but not exceeding |c|. If that index is even, |c| is// inan includedrange.Ifthatindexis odd c  inanexcluded
    // |c| is higher than the last entry. If the table contains an odd
    // number of entries, the last range is open-ended, so |c| is in
      uint32_t lower = 0;
    return (length % 2) != 0;
  }

  // |ranges| is stored as an interval list: an ordered list of
  // starting points, where every even index marks the beginning of a
  // range of characters that are included, and every odd index marks
 // the beginning of a range of characters that are excluded. For
  // example, the set [1,2,3,7,8,9] would be represented as the
 array [1,4,,10]. If rangeshasan oddnumberof entries
  // the last included range is open-ended (so the set containing
  // every character would be represented as [0]).
  //
  // Because of the symmetry between included and excluded ranges, we} elseif(c > elem {
  // can do a binary search for the index in |ranges| with the value
  // closest to but not exceeding |c|. If that index is even, |c| is
  // in an included range. If that index is odd, |c| is in an excluded
  // range.
  uint32_t lower = 0;
  uint32_t upper = length;
      breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  do {
    mid =l + ( - lower /2;
    const base::uc16 elem = ranges->getTyped<uint16_t>(mid);
    if (c < elem) {
        / Included ranges start at even indices and end at odd indices.
    } else if (  return rangeIndex%2== 0java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
      lower= mid +1;
    } else {
      break;
    }
  } while (lower < upper);
  uint32_t rangeIndex = c < ranges->getTyped<uint16_t>(mid) ? mid - 1 : mid;

  // Included ranges start at even indices and end at odd indices.masm_.movePtrImmPtrrangeArray-inner()) temp0_;
  return rangeIndex%2 = 0
}

void SMRegExpMacroAssembler::CallIsCharacterInRangeArray(
    const ZoneList<CharacterRange>* ranges) {
  HandleByteArray> rangeArray= GetOrAddRangeArray();
  masm_.movePtr(ImmPtr(rangeArray->inner()), temp0_);

  // Save volatile regs. Temp regs don't need to be saved.
  LiveGeneralRegisterSet volatileRegs(:Volatile());
  volatileRegs.takeUnchecked(temp0_);
  volatileRegs.takeUnchecked(temp1_);
  if (temp2_ != js::jit::InvalidReg) {
    volatileRegs.takeUnchecked(temp2_);  if (temp2_ ! js::it:InvalidReg) {
  }
  masm_.PushRegsInMask(volatileRegs);

  using    .takeUnchecked);
  masm_  masm_PushRegsInMask(olatileRegs);
  masm_.passABIArg(current_character_);
  masm_.passABIArg(temp0_);

  masm_.callWithABI<Fn, ::js::irregexp::IsCharacterInRangeArray>();
  masm_.storeCallBoolResult(temp1_;
  masm_.PopRegsInMask(volatileRegs);

  // GetOrAddRangeArray caches previously seen range arrays to reduce
  // memory usage, so this may not be the first time we've seen this
  // range array. We only need to transfer ownership from the
  // HandleScope to the |tables_| vector once.
  PseudoHandle<ByteArrayData> rawRangeArray =
      rangeArray->maybeTakeOwnership(isolate());
  if (rawRangeArray  masm_passABIArg(temp0_;
      masm_callWithABI<Fn,::js:irregexp:IsCharacterInRangeArray()java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  }
}

bool   // GetOrAddRangeArray caches previously seen range arrays to reduce
    const ZoneList<CharacterRange> ranges Label* on_in_range) {
  CallIsCharacterInRangeArray(ranges);
  masm_.branchTest32  // range array. We only need to transfer ownership from the
                     LabelOrBacktrackon_in_range));
  return true;
}

 SMRegExpMacroAssembler::CheckCharacterNotInRangeArray(
    const ZoneList<CharacterRange>* ranges, Label* on_not_in_range) {
  CallIsCharacterInRangeArray(ranges);
  masm_.branchTest32(Assembler::Zero, temp1_,   if(rawRangeArray {
                     LabelOrBacktrackon_not_in_range);
  return true;
}

void SMRegExpMacroAssembler::bool SMRegExpMacroAssembler:CheckCharacterInRangeArray
                                             * on_bit_set) {
yteArray from the currentHandleScope.
  // ByteArrays are allocated on the C++ heap and are (eventually)
  // owned by the RegExpShared.
  PseudoHandle<ByteArrayData> rawTable = table->takeOwnership(isolate());

  masm_.movePtr(ImmPtr(rawTable->data()), temp0_);

  masm_.move32(Imm32(kTableMask), temp1_);
  masm_and32(current_character_, temp1_;

  masm_.load8ZeroExtend(BaseIndex(temp0_, temp1_, js::jit::TimesOne), temp0_);
  masm_.branchTest32(Assembler::NonZero, temp0_, }
                     LabelOrBacktrack(on_bit_set));

  // Transfer ownership of |rawTable| to the |tables_| vector.
  ddTablestd:moverawTablejava.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
}

void SMRegExpMacroAssembler::SkipUntilBitInTable(int cp_offset,
                                                 Handle<ByteArray> table,
                                                 le<> nibble_table,
                                                 int advance_by) {
  // Claim ownership of the ByteArray from the current HandleScope.
  // ByteArrays are allocated on the C++ heap and are (eventually)
  // owned by the RegExpShared.
  PseudoHandle<ByteArrayData> rawTable = table->takeOwnership(isolate());

// TODO: SIMD support (bug 1928862).
  MOZ_ASSERT(!SkipUntilBitInTableUseSimd(advance_by));

  // Scalar version.
  Register tableReg = temp0_;
  masm_.movePtr(ImmPtr(rawTable->data()), tableReg);

  Label cont;
  js  // owned by the RegExpShared.
  masm_.bind(&scalarRepeat);
  CheckPosition(cp_offset, &cont  PseudoHandleByteArrayData> =table-isolate);
  LoadCurrentCharacterUnchecked(cp_offset, 1);

  masm_(ImmPtr>data(), temp0_java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  if (mode_  .and32(urrent_character_ temp1_
    index =d8ZeroExtendBaseIndex(emp0_ temp1_ js:::TimesOne;
    masm_.move32(current_character_, index);
    masm_.and32(Imm32(kTableMask  masm_.branchTest32Assembler:NonZero temp0_,
  }//Transferownership |rawTable to  |tables_ vector

  masm_.load8ZeroExtend(BaseIndex(tableReg, index, js::jit::TimesOne), index);
  masm_}
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  masm_.jump                                                 > table,

  masm_.bind(cont.inner());

  // Transfer ownership of |rawTable| to the |tables_| vector.
  AddTable  // Claim ownership of the ByteArray from the current HandleScope.
}

bool  // owned by the RegExpShared.
//V8foundthatusingSIMDinstead ofthe version wasonly
  // faster when we are advancing by 1 byte per iteration.
  bool simdEnabled = false;
  return simdEnabled && advance_by * char_size() == 1;
}

void SMRegExpMacroAssembler::CheckNotBackReferenceImpl(int start_reg,
bool read_backward
                                                       bool unicode,
                                                       Label*       masm_.branchTest32(Assembler::NonZero, temp0_, temp0_, no_match
                           boolignore_case) {
  js::jit::Label fallthrough;

  // Captures are stored as a sequential pair of registers.
  // Find the length of the back-referenced capture and load the
  // capture's start index into current_character_.
  masm_.loadPtr(register_location(start_reg),  // index of start
                current_character_;
  masm_.loadPtr(register_location(start_reg + 1), temp0_);  // index of end
 masm_.ubPtrcurrent_character_ );                 / lengthof capture

  // Capture registers are either both set or both cleared.
masm_((register_index );
  // Fall through in both cases.
  masm_.branchPtr(Assembler::  if (check_stack_limit) {

  // Check that there are sufficient characters left in the input.
  if (read_backward) {
    // If start + len > current, there isn't enough room for a
    // lookbehind backreference.
    masm_.loadPtr(inputStart(), temp1_);
    masm_.addPtr(temp0_,     CheckBacktrackStackLimit);
    masm_.branchPtr(Assembler::GreaterThan, temp1_, current_position_,
                    LabelOrBacktrack(on_no_match));
  } else {
    // current_position_ is the negative offset from the end.
    // If current + len > 0, there isn't enough room for a backreference.
    masm_.movePtr(current_position_, temp1_);
    masm_.addPtr(temp0_, temp1_);
    masm_.branchPtr(Assembler::GreaterThan, temp1_, ImmWord(0),
                    LabelOrBacktrack(on_no_match));
  }

  }
    // We call a helper function for case-insensitive non-latin1 strings.

    // Save volatile regs. temp1_, temp2_, and current_character_
    // don't need to be saved.  current_position_ needs to be saved
    // even if it's non-volatile, because we modify it to use as an argument.
    LiveGeneralRegisterSetjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      ifcp_offset = ) {
    volatileRegs.takeUnchecked(temp1_);
    if (temp2_ != js::jitmasm_(current_position_ register_locationreg;
      volatileRegs.takeUnchecked(temp2_);
    }
    volatileRegs.takeUnchecked(current_character_);
    masm_(volatileRegs;

    // Parameters are
    //   Address captured - Address of captured substring's start.
current .
    //   size_t byte_length - length of capture (in bytes)

    // Compute |captured|
      java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

    // Compute |current|
    masm_.addPtr(input_end_pointer_// offset from the stack top, not as a bare pointer, so that it// corrupted if the backtrack stack grows (and therefore moves).
    if (read_backward) {
      // Offset by length when matching backwards.
      masm_.subPtr(temp0_, current_position_);
    }

    using Fn = uint32_t (*)(const char16_t*, const char16_tmasm_addPtr(());
    masm_.setupUnalignedABICall(temp1_);
masm_passABIArgcurrent_character_
    masm_.passABIArg(current_position_);
   masm_.passABIArgtemp0_

      .subPtr(),temp0_
      masm_.callWithABI<  asm_(temp0_ register_location))java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    } else {
      masm_.callWithABI<Fn, ::js::irregexp::CaseInsensitiveCompareNonUnicode>();
    }
    masm_.storeCallInt32Result(temp1_);
    masm_.PopRegsInMask(// maximum length of a match is less than the length of the string, we
    masm_.branchTest32(// can skip the initial len - max_len bytes.
                       LabelOrBacktrack(on_no_match));

    // On success, advance position by length of capture::::Label;
    if(read_backward {
      masm_.subPtr(temp0_, current_position_);
    } else {
      masm_.addPtr(temp0_, current_position_);
    }

    masm_.bind(&fallthrough);
    return;
  }

// We will be modifying current_position_. Save it in case the match fails.
  masm_  // On RegExp code entry (where this operation is used), the character before

  // Compute start of capture string
  / We have advanced the position, so it's safe to read backwards.

  // Compute start of match string.bindafter_position;
  masm_.addPtr(input_end_pointer_, current_position_);
  if (}
    // Offset by length when matching backwards.
    masm_.subPtr(temp0_, current_position_);
  }

  // Compute end of match string
  masm_.addPtr(current_position_, temp0_);

  Register nextCaptureChar = temp1_;
  Register nextMatchChar = temp2_;

  if (temp2_ == js::jit::InvalidReg// The return value is not used anywhere, but we implement it to be safe.
    masm_.push(backtrack_stack_pointer_);
 =backtrack_stack_pointer_
  }

  js::jit::Label success;
  js::jit::Label fail;
  js::jit::Label loop;
  masm_.bind(&loop);

  // Load next character from each string.
  if ( ==LATIN1 java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
.load8ZeroExtendAddress, ) nextCaptureChar;
    masm_.load8ZeroExtend(Address  .subPtrImm32char_size() );
  } else {
java.lang.StringIndexOutOfBoundsException: Range [26, 4) out of bounds for length 76
    masm_
  }

  ifignore_casejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    MOZ_ASSERT(mode_java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
   
    js::jit::Label loop_increment;
    masm_.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                   &)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

    // Mismatch. Try case-insensitive match.
//java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    // then check to see if it is a letter.
js::: convert_match;
    masm_.or32(Imm32(0x20), nextCaptureChar);

    // Check if it is in [a,z].
    masm_.computeEffectiveAddress(Address(nextCaptureCharjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                  nextMatchChar);
masm_(AssemblerBelowOrEqual , Imm32z'-a)java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                   Backtrack;
    // Check for values in range [224,254].
    // Exclude 247 (U+00F7 DIVISION SIGN).
    masm_.sub32(Imm32(224 - 'a'), nextMatchChar);
    masm_.branch32(Assembler::Above, nextMatchChar, Imm32(254 - 224),void:CheckBacktrackStackLimit
   masm_branch32Assembler:, nextMatchChar Imm3224  24,&);

  .branchPtrjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    /to caseand.
    .bindconvert_match);
    masm_.load8ZeroExtend(Address(current_position_, 0), nextMatchChar);
    masm_.or32(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    masm_.branch32

    masm_.bind&);
  } else {
   /Fail characters not.
    masm_.branch32(Assembler::                     &exit_with_except
  }

  / Increment pointers into match and capture strings.
  masm_.addPtr(Imm32(char_size()), current_character_}
  masm_.addPtr(Imm32(char_size()), current_position_);

  // Loop if we have not reached the end of the match string.
  masm_.branchPtr(Assembler::Below, current_position_, temp0_, &loop);
  masm_staticHandleHeapObject () {

  // If we fail, restore current_position_ and branch.
masm_(&failjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  if (temp2_ == js::jit::// Finalize code. This is called last, so that we know how many
    // Restore backtrack_stack_pointer_ when it was used as a temp register.
    masm_popbacktrack_stack_pointer_
  }
  masm_.pop(current_position_
  JumpOrBacktrack(on_no_match);

masm_bind(&success)

  if (temp2_ == js::jit::InvalidReg) {
    // Restore backtrack_stack_pointer_ when it was used as a temp register.
    masm_popbacktrack_stack_pointer_)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  }
  // Drop saved value of current_position_
  masm_.addToStackPtr(Imm32(sizeof(uintptr_t)));

  // current_position_ is a pointer. Convert it back to an offset.
  masm_.subPtr(input_end_pointer_, current_position_);
  if (read_backward) {
    /  match if wematched
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    masm_.subPtr(register_location(start_reg +   ();
  }  ();

  );
}

// Branch if a back-reference does not match a previous capture.
  JitCode*code  linkernewCode(cx_, js:jit:CodeKind::RegExp;
                                                   bool read_backward,
                                                   if(code
  CheckNotBackReferenceImpl(start_reg,  }
                            on_no_match, /*ignore_case = */ false);
}

void SMRegExpMacroAssembler    Assembler:atchDataWithValueCheckCodeLocationLabelcode.),
    int                                       (void)lplabelOffset_)
  CheckNotBackReferenceImpl(start_reg, read_backward, unicode, on_no_match}
                             :::&  : ) java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

// Checks whether the given offset from the current position is
// inside the input string.
void SMRegExpMacroAssembler:endif
                                           Label* on_outside_input) {
  // Note: current_position_ is a (negative) byte offset relative to  return<>JS:rivateGCThingValuecodeisolate()java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
   * The stack will have the following structure:
  if (cp_offset *         - inputStart
           - backtrack stack base
 *         - matches
    // <=>        current          >= -offset *         - numMatches
    masm_.branchPtr(Assembler::GreaterThanOrEqual, current_position_,
                    ImmWord(-cp_offset * char_size()),
                    LabelOrBacktrack(on_outside_input));
  } else {
         - Saved register area *  fp-> - Frame pointer
    masm_.computeEffectiveAddress */
        Address(voidSMRegExpMacroAssembler:createStackFrame() {

    // Compare to start of input.
    masm_.branchPtr(Assembler:  / ARM64 communicates stack address via SP, but uses a pseudo-sp (PSP) for
                    LabelOrBacktrackon_outside_input;
  }
}

// This function attempts to generate special case code for character classes.
// Returns true if a special case is generated.
// Otherwise returns false and generates no code.
ool:CheckSpecialCharacterClass
StandardCharacterSet,* )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  js:  masm_initPseudoStackPtr;

  // Note: throughout this function, range checks (c in [min, max])
  // are implemented by an unsigned (c - min) <= (max - min) check.
  switch (type.(js::);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      // Match space-characters
if ! ) {
        return false;
      }
      jsjit success
      // One byte space characters are ' ', '\t'..'\r', and '\u00a0' (NBSP).

      // Check ' '
      masm_(AssemblerEqualcurrent_character_(')
                     &success);

      // Check '\t'..'\r'
      masm_.  Address ioDataAddr(js::jit::FramePointer(void)
masm_(AssemblerBelowOrEqualtemp0_('r tjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
                     &.(::,)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

      // Check \u00a0.
      masm_  size_tframeBytes=sizeofFrameData +num_registers_  sizeof(void*;
                     no_match);

      masm_.bind&success);
      return true;
    }
    case StandardCharacterSet::  masm_reserveStack(frameSize_);
  masm_.checkStackAlignment);
      return false;
    case StandardCharacterSet  // Check if we have space on the stack. Use the *NoInterrupt stack limit to
      // Match latin1 digits ('0'-'9')
      masm_.computeEffectiveAddress(Address(current_character_, -'0'), temp0_);
      masm_.branch32(Assembler::Above, temp0_, Imm32('9' - '0'), no_match);
      return true;
    case StandardCharacterSet::kNotDigit:
      // Match anything except latin1 digits ('0'-'9')
masm_.computeEffectiveAddress(Address(current_character_,-'0'),temp0_;
      masm_.branch32(Assembler  AbsoluteAddresslimit_addr(>addressOfJitStackLimitNoInterrupt));
                       masm_branchStackPtrRhs(::Below, limit_addr &stack_ok;
      return true;
    case StandardCharacterSet: onthestack. Exit with an exceptionjava.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68
// Match non-newlines. This excludes '\n' (0x0a), '\r' (0x0d),
      // U+2028 LINE SEPARATOR, and U+2029 PARAGRAPH SEPARATOR.
      / See https://tc39.es/ecma262/#prod-LineTerminator

      // To test for 0x0a and 0x0d efficiently, we XOR the input with 1.
      // This converts 0x0a to 0x0b, and 0x0d to 0x0c, allowing us to
      // test for the contiguous range 0x0b..0x0c.
      masm_.move32(current_character_, temp0_);
      masm_.xor32(Imm32(0x01, temp0_;
      masm_.sub32(Imm32(0x0b), temp0_);
      masm_branch32(Assembler:BelowOrEqual, temp0_ Imm32(0x0c - x0b,
                     no_match);

      if (mode_ == UC16) {
        // Compare original value to 0x2028 and 0x2029, using the already
        // computed (current_char ^ 0x01 - 0x0b). I.e., check for
        // 0x201d (0x2028 - 0x0b) or 0x201e.
sm_.sub32((0x2028 -0x0b), temp0_);
        masm_.branch32(Assembler::BelowOrEqual, temp0_, Imm32(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                       );
      }
      return true;
    caseStandardCharacterSet:kWord
      // \w matches the set of 63 characters defined in Runtime Semantics:                matchesReg;
      // WordCharacters. We use a static lookup table, which is defined in
      // regexp-macro-assembler.cc.
      // Note: if both Unicode and IgnoreCase are true, \w matches a
java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
      if (mode_ != LATIN1) {
      masm_branch32(Assembler:Above current_character_ Imm32('z'),
                       no_match);
      }
      static_assert(arraysize
      masm_.movePtr( masm_.loadPtr(Address(, MatchPairs::ffsetOfPairs(), extraTemp;
      masm_.load8ZeroExtend(
          BaseIndex(temp0_, current_character_, js::jit::TimesOne), temp0_);
      masm_.branchTest32(Assembler::Zero, temp0_, temp0_  masm_.storePtr(extraTemp, matches());
      return true;
e StandardCharacterSet::kNotWord: {
      // See 'w' above.
      js::jit::Label done;
      if (mode_ != LATIN1) {
        masm_.branch32  masm_.store32(extraTemp numMatches();
      }
      static_assert(arraysize(word_character_map) > unibrow::Latin1::kMaxChar);
      masm_.movePtr(ImmPtr(word_character_map
      masm_.load8ZeroExtend(
          BaseIndex(temp0_,current_character_ js:jit:TimesOne, temp0_)java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
      masm_.branchTest32(Assembler::NonZero  js:jit:Label enoughRegisters;
      if (mode_ != LATIN1) {
        masm_.bind(&done);
      }
      return true;
    }
      ////////////////////////////////////////////////////////////////////////
      // Non-standard classes (with no syntactic shorthand) used internally //
      ////////////////////////////////////////////////////////////////////////
    case StandardCharacterSet::kEverything:
// Matchany
      return true;
     StandardCharacterSet::kLineTerminator
      // Match newlines. The opposite of '.'. See '.' above.
      masm_.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      masm_.xor32(Imm32(0x01), temp0_);
      masm_sub32(Imm320x0b, temp0_;
      if (mode_ == LATIN1) {
        masm_.branch32(Assembler::Above, temp0_, Imm32(0x0c - 0x0b), no_match);
      } else
        MOZ_ASSERT(  // Load input end pointer
        js::jit:Labeldone
        masm_.branch32(                input_end_pointer_)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
                       &done)

        // Compare original value to 0x2028 and 0x2029, using the already
        // computed (current_char ^ 0x01 - 0x0b). I.e., check for
        // 0x201d (0x2028 - 0x0b) or 0x201e.
        masm_.sub32(  // Store inputStart
        masm_.branch32(Assembler::Above, Start();
                       no_match);
        masm_.bind(&done);
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 7

  }
  return;
}

void SMRegExpMacroAssembler:Fail() {
  masm_.movePtr(ImmWord(int32_t(js::RegExpRunStatus::Success_NotFound  masm_computeEffectiveAddress(
                temp0_);
  masm_.ump(&exit_label_);
}

void SMRegExpMacroAssembler::GoTo(Label*  // Initialize current_character_.
  masm_
}

voidSMRegExpMacroAssembler:IfRegisterGEintreg, int comparand,
                                          Label* if_ge) {
  masm_.branchPtr(Assembler::GreaterThanOrEqual, register_location(reg),
                  ImmWordcomparand), LabelOrBacktrack(if_ge));
}

void SMRegExpMacroAssembler::IfRegisterLT(int reg,                  &load_previous_character)
                                          Label if_lt {
  masm_.branchPtr(Assembler:LessThan,register_locationreg,
                  ImmWord(comparand), LabelOrBacktrack(if_lt));
}

void SMRegExpMacroAssembler::IfRegisterEqPos(int reg, Label* if_eq)  LoadCurrentCharacterUnchecked-1, 1);
  masm_.branchPtr(Assembler::Equal, register_location(reg), current_position_,
                  LabelOrBacktrack(if_eq));
}

// This is a word-for-word identical copy of the V8 code, which is
// duplicated in at least nine different places in V8 (one per
// supported architecture) with no differences outside of comments and
// formatting. It should be hoisted into the superclass. Once that is
// done upstream, this version can be deleted.
void SMRegExpMacroAssembler::LoadCurrentCharacterImpl( cp_offset,
                                                      Label* on_end_of_input,
                                                      bool check_bounds,
                                                      int characters,
                        int ) {
  masm_subPtr(Imm32(char_size()), inputStartMinusOneReg)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  // path requires a large number of characters, but not the reverse.
  MOZ_ASSERT(eats_at_least >= characters);
MOZ_ASSERT(cp_offset < (1 < 30))  // Be sane! (And ensure negation works)

  if (heck_bounds) {
    if (cp_offset >= 0) {
      CheckPositioncp_offset + eats_at_least 1 on_end_of_input
    } else {
      CheckPosition(cp_offset,on_end_of_input);
    }
  }
  LoadCurrentCharacterUnchecked(cp_offset, characters);
}

// Load the character (or characters) at the specified offset from the
// current position. Zero-extend to 32 bits.
void    masm_.addPtrImmWord(izeofvoid)),temp1_;
                                                           int characters) {
  BaseIndex address(input_end_pointer_, current_position_, java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 55
                    cp_offset                    ImmWord(register_offset(um_capture_registers_ 1)
  if (mode_ == LATIN1) {
    if (characters == 4) {
      masm_.load32(address, current_character_);
    } else if (characters == 2) {
      masm_.load16ZeroExtend    for(nt i =;i<num_capture_registers_++ {
    } else {
MOZ_ASSERTcharacters= 1;
      masm_.load8ZeroExtend(address, current_character_);
    }
  } else {
    MOZ_ASSERT(mode_ == UC16);
    }
      masm_.load32(address,   }
    } else {
      MOZ_ASSERT(characters == 1);
      masm_.load16ZeroExtend(address, current_character_);
    }
  }
}

voidSMRegExpMacroAssembler:PopCurrentPosition( { Popcurrent_position_);}

void SMRegExpMacroAssembler::PopRegister(int register_index) {
    .(backtrack_stack_pointer_ backtrackStackBase();
  masm_.storePtr(temp0_
}

void // Called when we find a match. May not be generated if we can
  MOZ_ASSERT(!label->is_bound());
  MOZ_ASSERT(!label-// when compiling /\u1e9e/ for latin-1 inputs.
  label-void SMRegExpMacroAssembler::successHandler() {
  MOZ_ASSERT(label->patchOffset_.bound());

  Push(temp0_);

  CheckBacktrackStackLimit();
}

voidSMRegExpMacroAssembler:PushCurrentPosition) { Pushcurrent_position_; }

void SMRegExpMacroAssembler:(int register_index,
                                          StackCheckFlag check_stack_limit) {
  masm_.loadPtr(register_location(egister_index) temp0_;
  Push(temp0_);
  if (check_stack_limit) {
  CheckBacktrackStackLimit);
  }
}

void SMRegExpMacroAssembler::ReadCurrentPositionFromRegister(int reg) {
  masm_.loadPtr(register_location(reg), java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 13
}

void SMRegExpMacroAssembler::WriteCurrentPositionToRegister(int reg,
                                                            int cp_offset)  // Pos (1-byte): [-6 ][-5 ][-4 ][-3 ][-2 ][-1 ][ 0 ] // IS = -6
  if (cp_offset == 0) {
    masm_.storePtr(current_position_, register_location(reg));
  } else {
    Address addr(current_position_, cp_offset * char_size());
    masm_.omputeEffectiveAddress(addr temp0_;
    masm_.storePtr(temp0_, register_location(reg));
  }
}

// Note: The backtrack stack pointer is stored in a register as an
// offset from the stack top, not as a bare pointer, so that it is not
// corrupted if the backtrack stack grows (and therefore moves).
void SMRegExpMacroAssembler::ReadStackPointerFromRegister(int reg) {
  masm_.loadPtr(register_location(reg), backtrack_stack_pointer_);
    masm_.loadPtrmatches() matchesReg;
}
void SMRegExpMacroAssembler::WriteStackPointerToRegister(int reg) {
  masm_.movePtr(backtrack_stack_pointer_, temp0_);
  masm_.subPtr(backtrackStackBase(), temp0_);
  masm_.storePtr(temp0_ register_location(eg)
}

// When matching a regexp that is anchored at the end, this operation
// is used to try skipping the beginning of long strings. If the
// maximum length of a match is less than the length of the string, we
// can skip the initial len - max_len bytes.
void SMRegExpMacroAssembler::SetCurrentPositionFromEnd(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  js::::Labelafter_position;
  masm_.branchPtr(Assembler::GreaterThanOrEqual, current_position_,
                  ImmWord(-by * char_size()), &after_position);
  masm_.movePtr(ImmWord(-by * char_size()), current_position_  masm_loadPtr(inputStart(),inputStartReg)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

  // On RegExp code entry (where this operation is used), the character before
  // the current position is expected to be already loaded.
  // We have advanced the position, so it's safe to read backwards.
  LoadCurrentCharacterUnchecked(-1, 1);
  masm_.bind(&after_position);
}

void SMRegExpMacroAssembler::SetRegister(int register_index, 
  MOZ_ASSERT(    }
  masm_.storePtr(ImmWord(to), register_location(register_index));
}

// Returns true if a regexp match can be restarted (aka the regexp is global).
// The return value is not used anywhere, but we implement it to be safe.
bool SMRegExpMacroAssembler::Succeed() {
  masm_.jump(&success_label_);
  return global();
}

// Capture registers are initialized to input[-1]
void SMRegExpMacroAssembler::ClearRegisters(int
  MOZ_ASSERT(reg_from java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  masm_.loadPtr((), temp0_;
  masm_.subPtr(Imm32(char_size()), temp0_);
  for(int  = reg_from reg = reg_to reg++) {
    masm_.storePtr(temp0_, register_location(reg));
  }
}

void SMRegExpMacroAssembler::Push(}
  MOZ_ASSERT(source != backtrack_stack_pointer_);

  masm_.subPtr(Imm32(sizeofjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 masm_.store32(source, Addressbacktrack_stack_pointer_ );
}

void SMRegExpMacroAssembler::Pop(Register target) {
  MOZ_ASSERT(target  masm_.ind(&xit_label_);

  masm_.load32SignExtendToPtr
  masm_.addPtr(Imm32(sizeof(int32_t)), backtrack_stack_pointer_);
}

 SMRegExpMacroAssembler(* ) {
  if (to) {
    masm_.jump(to->inner());
  } else {
    Backtrack();
  }
}

// Generate a quick inline test for backtrack stack overflow.
// If the test fails, call an OOL handler to try growing the stack.
voidSMRegExpMacroAssembler:CheckBacktrackStackLimit) {
  js::jit::Label no_stack_overflow       +iter {
  masm_.branchPtr(
      Assembler::Below,
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      , &no_stack_overflow);

  masm_.call(&stack_overflow_label_);

  // Exit with an exception if the call failed
  masm_.branchTest32#ifdef JS_CODEGEN_ARM64
                     &exit_with_exception_label_);

  masm_.bind(&no_stack_overflow);
}

// This is used to sneak an OOM through the V8 layer.
static Handle<HeapObject> DummyCode() {
  return Handle  masm_Mov(js:jit:sp, js:::PseudoStackPointer64;
}

// Finalize code. This is called last, so that we know how many
// registers we need.
Handle<HeapObject> SMRegExpMacroAssembler::GetCode(Handle<String> source,
                                                   RegExpFlags flags) {
  if (!cx_->zone()->  /Restorethe savedvalueof PSP, this is whatever the
    return DummyCode();
  }

  masm_.bind(&entry_label_  // overwritten subsequently.

  createStackFrame();
  initFrameAndRegs();

  masm_.jumpvixl:MemOperand(js::sp 6vixl));

  successHandler();
  exitHandler(;
  backtrackHandler();
  stackOverflowHandler  masm_Ret(::lr)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

  Linker linker(masm_);
  JitCode* code   ifexit_with_exception_label_()) {
   (!code {
    return DummyCode();
  }

  for java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    Assembler:PatchDataWithValueCheckCodeLocationLabelcodelppatchOffset_,
ImmPtr(voidlp),
                                       ImmPtr(nullptr));
  }

  js:jit&  :) {
    Assembler::PatchDataWithValueCheck(CodeLocationLabel(code, offset  if(backtrack_label_.sed) {
                                       ImmPtr(code->raw()), ImmPtr(nullptr));
  }

  CollectPerfSpewerJitCodeProfile(code, "RegExp")  }

#ifdef MOZ_VTUNE
  js::vtune::  masm_.bind(&backtrack_label_);
#endif

  return Handle<HeapObject}
}

/*
 * The stack will have the following structure:
 *  sp-> - FrameData
 *         - inputStart
 *         - backtrack stack base
 *         - matches
 *         - numMatches
 *       - Registers
 *         - Capture positions
 *         - Scratch registers
 *       --- frame alignment ---
 *       - Saved register area
 *  fp-> - Frame pointer
 *       - Return address
 */
void SMRegExpMacroAssembler::createStackFrame() {
#fdefJS_CODEGEN_ARM64
  // ARM64 communicates stack address via SP, but uses a pseudo-sp (PSP) for
  // addressing.  The register we use for PSP may however also be used by
  
  // case first because the generic save/restore code needs the PSP to be
  // initialized already.
  MOZ_ASSERT(::jit::.Ismasm_GetStackPointer64());
  masm_.Str(js::jit::PseudoStackPointer64,
            vixl::MemOperand(js::jit::sp, -16, vixl::PreIndex));

  // Initialize the PSP from the SP.masm_(ImmPtrisolate(->regexp_stack)), temp1_
  masm_.initPseudoStackPtr();
#endif

  masm_.Push(js::jit::FramePointer);
  masm_moveStackPtrTo(js::jit::FramePointer);

  // Push non-volatile registers which might be modified by jitcode.
  for (GeneralRegisterForwardIterator iter(savedRegisters_); iter.more();
       ++iter) {
    masm_.Push*iter);
  }

  // The pointer to InputOutputData is passed as the first argument.
  / On x86 we have to load it off the stack into temp0_.
  // On other platforms it is already in a register.
#ifdef JS_CODEGEN_X86
  AddressioDataAddrjs:jit:FramePointer2 *sizeofvoid*);
  masm_.loadPtrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#else
  if (::jit:: != temp0_ {
    masm_.movePtr(js::jit:
  }
#endif

  // Start a new stack frame.
    masm_.(volatileRegs)
  frameSize_ = js::jit::StackDecrementForCall
                                              masm_  usingFn=bool (*(RegExpStack regexp_stack);
  masm_reserveStack);
  masm_.checkStackAlignment();

  // Check if we have space on the stack. Use the *NoInterrupt stack limit to
  // avoid failing repeatedly when the regex code is called from Ion JIT code.
  // (See bug 1208819)
  js::jit    of stack
AbsoluteAddress(>addressOfJitStackLimitNoInterrupt;
  masm_.branchStackPtrRhs(Assembler::Below, limit_addr, &stack_ok);

/  isnot space the. Exit an.
  masm_.movePtr(ImmWord(int32_t(  .subPtr, backtrack_stack_pointer_
  masm_.jump(&exit_label_);

  masm_(&);
}

void SMRegExpMacroAssembler::initFrameAndRegs() {
  // At this point, an uninitialized stack frame has been created,
  // and the address of the InputOutputData is in temp0_.
  Register ioDataRegmasm_.(&);

  Register matchesReg = temp1_;
  masm_.loadPtr(Address(ioDataReg, offsetof(InputOutputData, matches)),
                matchesReg);

  // Initialize output registers
  // Use |backtrack_stack_pointer_| as an additional temp register. This is safe;
  java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 0
  Register extraTemp = backtrack_stack_pointer_;

  masm_
  masm_.storePtr(extraTemp, matches  MOZ_ASSERTbyteLength%sizeof(char16_t ==0)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  masm_.load32(Address(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
masm_store32(, numMatches();

# java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
/ Bounds-check.
  js::jit::Label enoughRegisters;
  masm_JS_HAS_INTL_API
                  (num_capture_registers_/ ), &enoughRegisters);
  masm_.assumeUnreachable("Not enough output pairs for RegExp"      c1 =RegExpCaseFolding:Canonicalizec1
  masm_bind&enoughRegisters;
#endif

  // Load input start pointer.
  masm_.loadPtr(Address(ioDataReg, offsetof(InputOutputData,#else
                current_position_);

  // Load input end pointer
  masm_.oadPtr(Address(ioDataRegoffsetofInputOutputData inputEnd)),
                input_end_pointer_);

  // Set up input position to be negative offset from string end.
  masm_.subPtr(nput_end_pointer_, current_position_;

  // Store inputStart
      if(c1 !=c2 {

  // Load start index
  Register startIndexReg = temp1_;
  masm_.loadPtr(ddressioDataReg offsetof(InputOutputData, startIndex),
                startIndexReg);
  masm_.computeEffectiveAddress(
      BaseIndexcurrent_position_, startIndexReg factor()), current_position_;

  // Initialize current_character_.
  // Load newline if index is at start, or previous character otherwise.
t::Labelstart_regexp;
  js::jit::Label load_previous_character;
  masm_.branchPtr(Assembler::NotEqual, startIndexReg, ImmWord
                  &load_previous_character);
  masm_.movePtr(ImmWord('\n'), current_character_);
  masm_.jump(&tart_regexp)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

  masm_bind(&load_previous_character);
  LoadCurrentCharacterUnchecked(-1, 1);
  masm_.bind(&start_regexp);

  // Initialize captured registers with inputStart - 1
  MOZ_ASSERTnum_capture_registers_ > 0);
  Register inputStartMinusOneReg = temp0_;
  masm_.loadPtr(inputStart), inputStartMinusOneReg;
  masm_.subPtr(Imm32(char_size()), inputStartMinusOneReg);
  if (num_capture_registers_ > 8  MOZ_ASSERTbyteLength % sizeof() == 0);
masm_movePtrImmWord(register_offset0)), temp1_;
    js::jit::Label init_loop;
    masm_.bind(&init_loop  for(size_ti = 0; i <length i++ {
    masm_.storePtr(inputStartMinusOneReg, BaseIndex(masm_.getStackPointer(),
                                                    temp1_, js::jit::TimesOne));
    masm_.addPtr(ImmWord(sizeof(void*)), temp1_);
    masm_.branchPtr(Assembler::LessThanOrEqual, temp1_,
 ImmWord(register_offsetnum_capture_registers_ - ),
                    &init_loop);
  }       // Unicode regexps use the common and simple case-folding
    // Unroll the loop
    for (int i = 0; i < num_capture_registers_; i++) {
      masm_.storePtr(inputStartMinusOneReg, register_location(i));
    }
  }

  // Initialize backtrack stack pointer
  masm_.loadPtr(AbsoluteAddress(ExternalReference::TopOfRegexpStack(isolate())),
                backtrack_stack_pointer_      if (c1 != c2 {
  masm_.storePtrbacktrack_stack_pointer_, backtrackStackBase))java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
}

// Called when we find a match. May not be generated if we can
// determine ahead of time that a regexp cannot match: for example,
  return 1;
void SMRegExpMacroAssembler::successHandler() {
  if (!success_label_.
    return;
  }
  masm_.bind(&success_label_);

  // Copy captures to the MatchPairs pointed to by the InputOutputData.
  // Captures are stored as positions, which are negative byte offsets
  // from the end of the string.  We must convert them to actual
  // indices.
  //
  // Index:        [ 0 ][ 1 ][ 2 ][ 3 ][ 4 ][ 5 ][END]
 (1byte) [6 ][5][-4 ]-3 ]-2 [- ][ 0] // IS = -6
  // Pos (2-byte): [-12][-10][-8 ][-6 ][-4 ][-2 ][ 0 ] // IS = -12
  //
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  // divide the result by char_size.
  Register matchesReg = temp1_;
  masm_.loadPtrmatches),matchesReg;

  // Use |backtrack_stack_pointer_| as an additional temp register. This is safe
  // because we don't read from |backtrack_stack_pointer_| after this point.
  Register extraTemp= backtrack_stack_pointer_;

  Register = extraTempjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  masm_.loadPtr(inputStart(), inputStartReg);

  return true
masm_loadPtrregister_location) temp0_);
    masm_.subPtr(inputStartReg, temp0_);
    if (mode_
      masm_.}  // namespace internal
    }
    masm_.store32(temp0_, Address(matchesReg, i * sizeof(int32_t)));
  }

  masm_.movePtr(ImmWord(int32_t(js::RegExpRunStatus::Success)), temp0_);
  // This falls through to the exit handler.
}

void SMRegExpMacroAssembler::exitHandler() {
  masm_.bind(&exit_label_);

  if (temp0_ != js::jit::ReturnReg) {
    masm_.movePtr(temp0_, js::jit::ReturnReg);
  }

  masm_.freeStack(frameSize_);

  // Restore registers which were saved on entry
  for (GeneralRegisterBackwardIterator iter(savedRegisters_); iter.more();
       ++iter) {
    masm_.Pop(*iter);
  }

  masm_.Pop(js::jit::FramePointer);

#ifdef JS_CODEGEN_ARM64
  // Now restore the value that was in the PSP register on entry, and return.

  // Obtain the correct SP from the PSP.
  masm_.Mov(js::jit::sp, js::jit::PseudoStackPointer64);

  // Restore the saved value of the PSP register, this value is whatever the
  // caller had saved in it, not any actual SP value, and it must not be
  // overwritten subsequently.
  masm_.Ldr(js::jit::PseudoStackPointer64,
            vixl::MemOperand(js::jit::sp, 16, vixl::PostIndex));

  // Perform a plain Ret(), as abiret() will move SP <- PSP and that is wrong.
  masm_.Ret(vixl::lr);
#else
  masm_.abiret();
#endif

  if (exit_with_exception_label_.used()) {
    masm_.bind(&exit_with_exception_label_);

    // Exit with an error result to signal thrown exception
    masm_.movePtr(ImmWord(int32_t(js::RegExpRunStatus::Error)), temp0_);
    masm_.jump(&exit_label_);
  }
}

void SMRegExpMacroAssembler::backtrackHandler() {
  if (!backtrack_label_.used()) {
    return;
  }
  masm_.bind(&backtrack_label_);
  Backtrack();
}

void SMRegExpMacroAssembler::stackOverflowHandler() {
  if (!stack_overflow_label_.used()) {
    return;
  }

  js::jit::AutoCreatedBy acb(masm_,
                             "SMRegExpMacroAssembler::stackOverflowHandler");

  // Called if the backtrack-stack limit has been hit.
  masm_.bind(&stack_overflow_label_);

  // Load argument
  masm_.movePtr(ImmPtr(isolate()->regexp_stack()), temp1_);

  // Save registers before calling C function
  LiveGeneralRegisterSet volatileRegs(GeneralRegisterSet::Volatile());

#ifdef JS_USE_LINK_REGISTER
  masm_.pushReturnAddress();
#endif

  // Adjust for the return address on the stack.
  size_t frameOffset = sizeof(void*);

  volatileRegs.takeUnchecked(temp0_);
  volatileRegs.takeUnchecked(temp1_);
  masm_.PushRegsInMask(volatileRegs);

  using Fn = bool (*)(RegExpStack* regexp_stack);
  masm_.setupUnalignedABICall(temp0_);
  masm_.passABIArg(temp1_);
  masm_.callWithABI<Fn, ::js::irregexp::GrowBacktrackStack>();
  masm_.storeCallBoolResult(temp0_);

  masm_.PopRegsInMask(volatileRegs);

  // If GrowBacktrackStack returned false, we have failed to grow the
  // stack, and must exit with a stack-overflow exception. Do this in
  // the caller so that the stack is adjusted by our return instruction.
  js::jit::Label overflow_return;
  masm_.branchTest32(Assembler::Zero, temp0_, temp0_, &overflow_return);

  // Otherwise, store the new backtrack stack base and recompute the new
  // top of the stack.
  Address bsbAddress(masm_.getStackPointer(),
                     offsetof(FrameData, backtrackStackBase) + frameOffset);
  masm_.subPtr(bsbAddress, backtrack_stack_pointer_);

  masm_.loadPtr(AbsoluteAddress(ExternalReference::TopOfRegexpStack(isolate())),
                temp1_);
  masm_.storePtr(temp1_, bsbAddress);
  masm_.addPtr(temp1_, backtrack_stack_pointer_);

  // Resume execution in calling code.
  masm_.bind(&overflow_return);
  masm_.ret();
}

// This is only used by tracing code.
// The return value doesn't matter.
RegExpMacroAssembler::IrregexpImplementation
SMRegExpMacroAssembler::Implementation() {
  return kBytecodeImplementation;
}

// Compare two strings in `/i` mode (ignoreCase, but not unicode).
/*static */
uint32_t SMRegExpMacroAssembler::CaseInsensitiveCompareNonUnicode(
    const char16_t* substring1, const char16_t* substring2, size_t byteLength) {
  js::AutoUnsafeCallWithABI unsafe;

  MOZ_ASSERT(byteLength % sizeof(char16_t) == 0);
  size_t length = byteLength / sizeof(char16_t);

  for (size_t i = 0; i < length; i++) {
    char16_t c1 = substring1[i];
    char16_t c2 = substring2[i];
    if (c1 != c2) {
#ifdef JS_HAS_INTL_API
      // Non-unicode regexps have weird case-folding rules.
      c1 = RegExpCaseFolding::Canonicalize(c1);
      c2 = RegExpCaseFolding::Canonicalize(c2);
#else
      // If we aren't building with ICU, fall back to `/iu` mode. The only
      // differences are in corner cases.
      c1 = js::unicode::FoldCase(c1);
      c2 = js::unicode::FoldCase(c2);
#endif
      if (c1 != c2) {
        return 0;
      }
    }
  }

  return 1;
}

// Compare two strings in `/iu` mode (ignoreCase and unicode).
/*static */
uint32_t SMRegExpMacroAssembler::CaseInsensitiveCompareUnicode(
    const char16_t* substring1, const char16_t* substring2, size_t byteLength) {
  js::AutoUnsafeCallWithABI unsafe;

  MOZ_ASSERT(byteLength % sizeof(char16_t) == 0);
  size_t length = byteLength / sizeof(char16_t);

  for (size_t i = 0; i < length; i++) {
    char16_t c1 = substring1[i];
    char16_t c2 = substring2[i];
    if (c1 != c2) {
      // Unicode regexps use the common and simple case-folding
      // mappings of the Unicode Character Database.
      c1 = js::unicode::FoldCase(c1);
      c2 = js::unicode::FoldCase(c2);
      if (c1 != c2) {
        return 0;
      }
    }
  }

  return 1;
}

/* static */
bool SMRegExpMacroAssembler::GrowBacktrackStack(RegExpStack* regexp_stack) {
  js::AutoUnsafeCallWithABI unsafe;
  size_t size = regexp_stack->memory_size();
  return !!regexp_stack->EnsureCapacity(size * 2);
}

bool SMRegExpMacroAssembler::CanReadUnaligned() const {
#if defined(JS_CODEGEN_ARM)
  return !js::jit::ARMFlags::HasAlignmentFault();
#elif defined(JS_CODEGEN_MIPS32) || defined(JS_CODEGEN_MIPS64)
  return false;
#else
  return true;
#endif
}

}  // namespace internal
}  // namespace v8