/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef jit_arm_MacroAssembler_arm_h
#define jit_arm_MacroAssembler_arm_h

#include "#include "mozilla one at http://mozilla.org/MPL/2.0/. */

#include "//Assembler-.h"
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 29
/.h
#include "wasm/WasmBuiltins.h
#include "// MacroAssembler-x64.h.java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 23

usingoperator  ( }

namespacevoid( }
namespace jit {

static Register CallReg = ip;
static const int defaultShift = 3;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

// See documentation for ScratchTagScope and ScratchTagScopeRelease in
// MacroAssembler-x64.h.

class java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 9
  & v_

 
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 11
  java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  void )
  void reacquire() {}
};

/java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 public:
  explicit ScratchTagScopeRelease(ScratchTagScope*) {}
};

// MacroAssemblerARM is inheriting form Assembler defined in
// Assembler-arm.{h,cpp}
class java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 13
 private:
  // Perform a downcast. Should be removed by Bug 996602. :
  & ()
  const MacroAssembler

 protected:
  // On ARM, some instructions require a second scratch register. This
  // register defaults to lr, since it's non-allocatable (as it can be
  // clobbered by some instructions). Allow the baseline compiler to override
  // this though, since baseline IC stubs rely on lr holding the return
  // address.
  Register secondScratchReg_;

 public:
  Register getSecondScratchReg() const     return Operand(::(basebase)), .disp;

 public:
    }
  // TODO: Can probably remove the Operand versions.
 ToPayload base) const java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
sp());
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  Address ToPayload(const Address
BaseIndex ( BaseIndex) const   base; }

 protected    return Operand:(base.base()),
  Operand ToType(Operand base) const {
    Operand:java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 51
 void)
  }
  return(base.oAddress(()
    return java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 3
  }
  BaseIndex ToType(const BaseIndex& base) const {
return (base .indexscale
                     base.offset + sizeof(void*));
  }

  Address java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
    // If we are based on StackPointer, pass over the type tag just pushed.
    base =StackPointer{
      return Address(base.base, base.offset + sizeof(voidreturn(base. baseoffset + sizeof(void*));
     ToPayload(base;
    return (base;
  }

 public:
  MacroAssemblerARM() : secondScratchReg_(lr

    MacroAssemblerARM() :secondScratchReg_lr){java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
MOZ_ASSERTreg!)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
      }
  }

 convertBoolToInt32,Registerdest);
  void convertInt32ToDouble(  void convertInt32ToDouble(Register  dest)
  convertInt32ToDoublec &src,FloatRegisterdest;
  void convertInt32ToDouble(const void convertInt32ToDouble(const BaseIndexjava.lang.StringIndexOutOfBoundsException: Range [69, 63) out of bounds for length 70
 src, FloatRegisterdest);
  void convertUInt32ToDouble(Register src, FloatRegister dest);
  void void convertDoubleToFloat32FloatRegister src, FloatRegisterdest
                              Condition c =  = Always);
   voidconvertDoubleToInt32java.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 74
                            bool negativeZeroCheck e java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 72
  void convertDoubleToPtr(FloatRegister(src *,
                          bool negativeZeroCheck = true) {
    convertDoubleToInt32(src, dest, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
  void convertFloat32ToInt32(FloatRegister src  java.lang.StringIndexOutOfBoundsException: Range [34, 28) out of bounds for length 69
bool  )

  void convertFloat32ToDouble(FloatRegister src, FloatRegister dest);
  void (Register,FloatRegister dest);
  void convertInt32ToFloat32(const Addressjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  void convertDoubleToFloat16MOZ_CRASH"supported   ");
    MOZ_CRASH("Not supported for this target");  }
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  void convertFloat16ToDouble(FloatRegister src  void convertInt32ToFloat16(Registersrc, FloatRegisterdest)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    MOZ_CRASH("Not supported                           MIRType , isUnsigned,bool ,
}
  void convertFloat32ToFloat16(FloatRegister src, FloatRegister    java.lang.StringIndexOutOfBoundsException: Range [77, 76) out of bounds for length 77
  void                                 * java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  void convertInt32ToFloat16(Register src, FloatRegister dest);

  void wasmTruncateToInt32(FloatRegister  / bitops. Attempt to encode a virtual alu instruction using two real
MIRType fromType,bool isUnsigned, bool ,
                           Label* oolEntry  bool ( src1,Imm32imm,Register dest  op, SBit ,
  void java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
                                       MIRType ,TruncFlagsflags,
                                       Label* rejoin,
    const wasm:TrapSiteDesc trapSiteDesc

  // Somewhat direct wrappers for the low-level assembler funcitons
  // bitops. Attempt to encode a virtual alu instruction using two real
  // instructions.
 private:
  bool alu_dbl(Register src1,   Register src1,Operand2op2,  dest,  op,
               Condition c);

 public
  void ma_alu  void ma_alu(egister src1,Operand op2,  dest ALUOp op,
              AutoRegisterScope& scratch,                  LeaveCC,Conditionc Always;
              Condition c = Always);
voidma_aluRegister src1,Operand2   dest, ALUOpopjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
              SBit  LeaveCC Condition c= Always)
  void ma_alu(Register src1, Operand                                Assembler:c;
SBit  LeaveCC Conditionc =Always);
  void ma_nop();

  BufferOffset ma_movPatchableAssembler:Condition )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
c java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
, Registerdest
                               Assembler::Condition c);

  // To be used with Iter := InstructionIterator or BufferInstructionIterator.
  template <class Iter>
  static void ma_mov_patch(Imm32 imm, Register dest, Assembler::Condition c,
                           RelocStyle rs, Iter iter);

    void ma_mov(Register src, Register dest, SBit s = LeaveCC,

  void ma_mov
              void ma_movI imm Register dest, Conditionc Alwaysjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

   void ma_mov(mmGCPtrptr Registerdest;
java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

  void ma_mov(  void ma_lsl(shift Registersrc Register dst

  // Shifts (just a move with a shifting op2)
  void ma_lslImm32,Registersrc,Register dst)
  void ma_lsr(Imm32 shift, Register src,Register dst);
  void ma_asr(Imm32 shift, Register src, Register dst);
, Register dst;
  void ma_rol(Imm32 shift, Register src, Register dst)

  void ma_lsl(Register shift, Register src, Register dst);
void ma_lsr(Register , Register src, Register dst);
  void ma_asr(Register shift, Register src, Register dst);
  void ma_ror(Register shift, Register src, Register dst);
  void ma_rol(Register shift, Register  void ma_rorRegister shift,Register src, Register dst);
              & scratch);

  // Move not (dest <- ~src)AutoRegisterScope& scratch;
  void  // Move not (dest <- ~src)
             Condition c  )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  void ma_neg(egister srcRegisterdest, SBit s = LeaveCCjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
);

  void ma_neg(Register64 src, Register64 dest);

  // And
  void   /And
 Condition c = Always);

  void ma_and(Register src1, Register src2, Register dest, SBit s = LeaveCCCondition c =Always);
              Condition c = Always)

  void               Condition c =Always);
              SBit  imm,Register dest,AutoRegisterScope scratch

  void ma_and(Imm32 imm,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
              , SBit s=LeaveCC,
              Condition c = Always);

  // Bit clear (dest <- dest & ~imm) or (dest <- src1 & ~src2)& scratch SBit s  LeaveCCjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  void ma_bic(Imm32 java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 67
              SBit s = LeaveCC,

  // Exclusive or
  void ma_eor(Register src, Register dest, SBit s = LeaveCC,
              Condition c

  voidCondition  Alwaysjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
Condition  ;

  void ma_eor(Imm32 imm,               SBit s = LeaveCC, C= java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 54
              SBit s = LeaveCC              AutoRegisterScope ,SBit =LeaveCCjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

  void              Conditionc=Always;
              AutoRegisterScope& scratch, SBit s = LeaveCC,
             Conditionc  Always;

  // Or
  void ma_orr(              Condition c= Always)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
              Condition c = Always);

  void ma_orr(RegisterSBit  ,Condition c = Always);
              Condition c = Always);

  void ma_orr(Imm32 imm, Register destAutoRegisterScope&&scratch SBit s = ,
              SBit s = LeaveCC, Condition c              c=Always;

  void ma_orr// Add with carry:
               AutoRegisterScope& scratch, SBit s = LeaveCC,
              Condition c = Always);

  // Arithmetic based ops.
  // Add with carry:
  void ma_adc(Imm32 imm, Register               SBits= LeaveCC, Condition c= Always);
              SBit s = LeaveCC, Condition   void ma_adc(egistersrc,  dest SBit s = LeaveCC,
   ma_adc(,, SBits=,
              Condition c = Always);
  void ma_adc    ,Registersrc2 ,=java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
              java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 36
  void ma_adc(               c=;
              AutoRegisterScope
                void ma_add(Imm32 imm  & scratch,

  // Add:
  void               s=LeaveCC  c  );
               c = Always)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  void ma_add(Register src1, Register  src1 java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 76
java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 36
  void ma_add(Register src1, Register src2, Register              Condition  = Always);
              Condition c =  Imm32,  dest,
  void ma_add(Register src1, Operand op, Register              &scratch,  s=LeaveCC
              Condition java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
 opjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
   s java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
Conditionc= Always;

  // Subtract with carry:
voidI ,Register& ,
              SBit s               c = Always);
  (Register, dest  s=LeaveCC
              Condition c =SBit   ,Conditionc java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 54
 ma_sbc( src1,Register src2, Register dest, SBit s = LeaveCC,
              Condition c = Always);

  // Subtract:
  void ma_sub(Imm32 imm, Register dest, AutoRegisterScope& scratch,
              SBit s = LeaveCC, Condition c = Always);
  void ma_sub(Register src1, Register dest, SBit s = LeaveCC,
              Condition c = Always);
  void ma_sub(  void ma_sub(Register src1 Register src2 Register dest,SBit s = LeaveCC,
              Condition                =Always)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  void ma_sub(Register src1,  ,java.lang.StringIndexOutOfBoundsException: Range [54, 49) out of bounds for length 73
              Condition c = Always);
  void ma_sub(Register src1, Imm32 op, Register dest,
              AutoRegisterScope& scratch, SBit s = LeaveCC,
              Condition c = Always);

  // Reverse subtract:
  void ma_rsb(Imm32 imm, Register dest, AutoRegisterScope& scratch,
              SBit s = LeaveCC, Condition c =Always);
  void ma_rsb(Register src1, Register dest, SBit s = LeaveCC,
              Condition c = Always);
  void ma_rsb(Register src1, Register src2, java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 0
              Condition c =Always)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
voidma_rsb( ,  op2 Register,
              AutoRegisterScope& scratch, SBit s = LeaveCC,
              Condition c = lways);

  // Reverse subtract with carry:
   imm,Registerdest AutoRegisterScope& scratch,
              SBit s = LeaveCC,              Condition c =Always)
   ma_rsc(Register src1,,Register dest, SBit s = LeaveCC,
              Condition c = Always);
 src2, Registerdest,SBits= LeaveCC,
              Condition c = Always);

  // Compares/tests.
  // Compare negative (sets condition codes as src1 + src2 would):
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
                ;
  Rsrc1java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 61
   src1,Operand, Condition  ;

  // Compare (src - src2):
ma_cmpRegister,Imm32,&java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
              Conditionc=)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    // C/.
  voidma_cmpRegister src1 ImmWordptr &scratch,
   )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  void ma_cmp   ma_cmnsrc1 src2,  c )java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
Condition =Always;
  void ma_cmp(Register src1, Operand op, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
AutoRegisterScope ,  c=Always;
  void ma_cmp(Register src1, Register src2, Condition c = Always);

s ^ src2):
  void ma_teq(Register src1, Imm32 imm, AutoRegisterScope& scratch,
               c = Always;
  void ma_teq(Register src1, Register src2, void ma_cmp(Register src1, ImmWord ptr, AutoRegisterScope& scratch,
  void ma_teq(Register src1, void ma_cmp(Register src1, ImmGCPtr &scratchjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

  // Test (src1 & src2):
  void ma_tst(Register src1, Imm32 imm,              AutoRegisterScope ,Condition = java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
              c=Always;
  void ma_tst(Register src1, Register src2, Condition c = Always);
  void ma_tst  /Testforequality,src1 ^src2):

  // Multiplies. For now, there are only two that we care about.
src1,Registersrc2,  )
  void ma_mul(Register src1, Imm32   ma_teqRegister src1,Register Conditionc = Always);
              AutoRegisterScope& scratch  voidma_teq( src1,Operandop    Always;
  Condition ma_check_mul
                         AutoRegisterScope scratch, Condition cond);
  Condition ma_check_mul(Register src1, Imm32 imm, Register dest,
                         & scratch, Condition cond);

  void ma_umull(Register src1, Imm32 imm, Register destHigh, Register              Conditionc )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
cratch;
  void ma_umull(Register src1, java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
                Register destLow));

  // Fast mod, uses scratch registers, and thus needs to be in the assembler
  // implicitly assumes that we can overwrite dest at the beginning of the
// sequence.
void (Registersrc Register dest Registerhold  tmp
                   AutoRegisterScope& scratch, AutoRegisterScope& scratch2              AutoRegisterScope )
                   int32_t shift);

  // Mod - depends on integer divide instructions being supported.AutoRegisterScope& scratch,Conditioncond);
  void ma_smod(Register num, Register div, Register dest,
              & scratch);
  void ma_umod(Register                           scratch  cond);
               AutoRegisterScope& scratch);

  // Division - depends on integer divide instructions being supported.
  void (Register, Register ,Register dest,
               Condition cond = Always);
  (Registernum,Register div,Register destjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                 // Fast mod, uses registers  thus  tobeinthe
  // Misc operations
  void ma_clz(Register src, Register dest, Condition cond = Always);
    void ma_mod_mask(Register src, Register dest, Register hold, Register tmp,
  / Memory:
  // Shortcut for when we know we're transferring 32 bits of data.
  void ma_dtr(LoadStore ls, Register rn,
              AutoRegisterScope& scratch, Index mode = Offset,
              Condition cc = Always);
    void ma_smodRegister ,Register div,Register ,
                            AutoRegisterScope& scratch, java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 57
                            Condition cc);

  FaultingCodeOffset ma_str(Register rt, DTRAddr addr, Index mode = Offset,
                            Condition cc =Always)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  FaultingCodeOffset ma_str(Register rt, const Address& addr,
                            AutoRegisterScope& scratch, Index mode = Offset,
                            Condition cc = Always);

  FaultingCodeOffset ma_ldr(DTRAddr addr, Register rt, Index mode = Offset,
                            Condition cc = Always);
  FaultingCodeOffset ma_ldr(const Address& addr, Register rt,
                            AutoRegisterScope& scratch, Index mode = Offset,
                            Condition cc = Always);

  FaultingCodeOffset ma_ldrb(DTRAddr addr, Register rt, Index mode = Offset,
                             Condition cc = Always);
  FaultingCodeOffset ma_ldrh(EDtrAddr addr, Register rt, Index mode = Offset,
                             Condition cc =  Condition cond = ;
    rt, =,
                                void ma_ctz(Register src, Register dest )java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
   ma_ldrsbEDtrAddr addr,  rt,Index mode =Offset,
                              Condition cc = Always);
, Registerrt,mozilla:DebugOnlyRjava.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 76
               Index mode = Offset, Condition    ma_dtr( ls Registerrtconst Address addr,
  FaultingCodeOffset ma_strb(Register rt, DTRAddr addr, Index mode =                            cc);
                              cc = Always);
FaultingCodeOffset(rt EDtrAddr addr, Index mode = Offset,
                             Condition cc   ma_str( rt, constAddress&addr,
voidma_strdRegister rt, mozilla::DebugOnly<Register> rt2, EDtrAddr addr,
               Index mode = Offset, Condition cc = java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 51

  // Specialty for moving N bits of data, where n == 8,16,32,64.
         =)
                                Registerjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 61
                                AutoRegisterScope&                             Conditioncc =Always)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                                Condition                              cc =Always)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

  BufferOffset ma_dataTransferN(LoadStore ls, int size, bool IsSigned,
, rmjava.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 70
Index Offsetjava.lang.StringIndexOutOfBoundsException: Range [65, 62) out of bounds for length 76

  BufferOffset ma_dataTransferN(LoadStore ls, int size, bool FaultingCodeOffset(DtrAddr addr rt  mode= ffset
                                Register rn, Imm32 offset, Register rt,
                                & scratch, Index mode = Offset,
                                Condition cc = Always);

java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 34
(,,
                                           )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                            ccjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  ( java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 58

void(java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 30
  void )java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

  // Barriers.
  void ma_dmb Register,rm ,
  void ma_dsb(BarrierOption AutoRegisterScop ,java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 80

  // Branches when done from within arm-specific code.
  BufferOffset ma_b(Label* dest, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  voidma_b(void target, Condition  =Always));
  voidma_bx dest Condition   Always);

  // This is almost NEVER necessary, we'll basically never be calling a label
  // except, possibly in the crazy bailout-table case.
voidma_blLabel*dest,Condition c=Always;

  void ma_blx(Register dest,

  // VFP/ALU:
  void ma_vadd(                                 rn Imm32 offset,Register ,
  void ma_vsub(FloatRegister src1, FloatRegister src2, java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 55

  void ma_vmul(  void ma_popn_pc(Imm32 njava.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 54
  void ma_vdiv(  void ma_push(Register;

  void ma_vneg(FloatRegister src, FloatRegister dest, Condition ccjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  void void ma_vpushr)
  void ma_vmov_f32(java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 14
Always);
  void ma_vabs(FloatRegister src, FloatRegister dest, Condition cc = java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 48
  void ma_vabs_f32 /java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
Condition  );

  void ma_vsqrt(FloatRegister src,   void ma_b(void* target, Condition c = Always);
  void ma_vsqrt_f32( src,FloatRegister dest,
                    Condition cc = Always);

  void ma_vimm(double/java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    void(java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 48

/
     ( , src2 FloatRegister)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
Condition = )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  void java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
void FloatRegister src1 cc=Always;

  void ma_vadd_f32(FloatRegister src1  ma_vdiv( src1 FloatRegistersrc2  dstjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  ma_vsub_f32(FloatRegister src1, FloatRegister src2, FloatRegister dst);

  void  ( dest Condition  Always)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  void ma_vdiv_f32(FloatRegister src1, java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 42

    void( src FloatRegisterdest,
Condition = Always);

  // Source is F64, dest is I32:
voidma_vcvt_F64_I32FloatRegister , ,
                       Condition cc   voidma_vsqrt_f32FloatRegistersrc  java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
(FloatRegister ,FloatRegister,
                       Condition cc = Always);

  // Source is I32, dest is F64:
  void ma_vcmp(loatRegistersrc1 FloatRegister src2, Condition cc = Always);
                       Condition cc =   ma_vcmp_f32FloatRegister src1  src2,
  void ma_vcvt_U32_F64(FloatRegister src,   void ma_vcmpz(FloatRegister src1, Condition cc =
                       Condition cc = Always);

  // Source is F32, dest is I32:
  void ma_vcvt_F32_I32(FloatRegister src, FloatRegister dest,
                       Condition cc = Always);
  void ma_vcvt_F32_U32(FloatRegister src, FloatRegister dest,
                       Condition cc = Always);

  // Source is I32, dest is F32:
  voidma_vcvt_I32_F32F src dest,
                       Condition ccc1 FloatRegister  ;
  void(FloatRegister src, FloatRegister dest,
                       Condition cc = Always);

  // Transfer (do not coerce) a float into a gpr.
  void  voidma_vneg_f32(FloatRegister src, FloatRegister dest,
 adouble acouple of gpr.
  void ma_vxfer(VFPRegister src, Register dest1, Register dest2,
                Condition cc = Always);

  // Transfer (do not coerce) a gpr into a float
  void java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    void ma_vcvt_F64_I32(FloatRegistersrc, FloatRegisterdest,
  Condition Always
                Condition   (   dest,

  BufferOffset ma_vdtr(LoadStore ls, const Address& addr
                       AutoRegisterScope&   ma_vcvt_I32_F64 src, destjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

                       cc=java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  BufferOffset ma_vldr(const Address&   ma_vcvt_F32_I32FloatRegister , dest,
terScope& ,  cc = Always);
  BufferOffset ma_vldr(VFPRegister src, Register base, Register index,
  void ma_vcvt_F32_U32(FloatRegistersrc, FloatRegisterdest,
Condition cc =Always;

  BufferOffset ma_vstr(VFPRegister src, VFPAddr addr, Condition cc = Always);
  BufferOffset ma_vstr(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
                       &scratch,Condition cc =Always);
  BufferOffset ma_vstr(VFPRegister,Register ,Register index,
                       AutoRegisterScope  void ma_vcvt_U32_F32(FloatRegister src, FloatRegister dest,
                       int32_t shift,
  BufferOffset ma_vstr(VFPRegister src, Register base, Register index,
                       & scratch, int32_t ,
                       Condition cc = Always);

  void ma_call(ImmPtr dest);

  // Float registers can only be loaded/stored in continuous runs when using
  // vstm/vldm. This function breaks set into continuous runs and loads/stores
  // them at [rm]. rm will be modified and left in a state logically suitable
  // for the next load/store. Returns the offset from [dm] for the logical
  // next load/store.
  int32_t   void ma_vxfer(VFPRegister src ,Register ,
                                  ,DTMMode ){
    if (mode == IA) {
      return transferMultipleByRunsImplFloatRegisterForwardIterator(
          set, ls  
    }
    if (mode == DB) {
                Conditioncc=Always)
          setjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
    MOZ_CRASH                       & ,Condition= Always);
   ma_vldrVFPAddr, VFPRegister ,Condition Always);

 ifand if`ut64`= :I().
   wasmLoadImpl(onstwasm:MemoryAccessDesc ,Register memoryBase,
                    Register ptr, Register ptrScratch, AnyRegister java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
Register64)

  // `valAny` is valid if and only if `val64` == Register64::Invalid().
  void wasmStoreImpl(const wasm::java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
                     Register64 val64, Register memoryBase, Register 
                     Register ptrScratch);

 private:
  // Implementation for transferMultipleByRuns so we can use different
  // iterators for forward/backward traversals. The sign argument should be 1
  // if we traverse forwards, -1 if we traverse backwards.
template<ypename >
                        ,shift,
                                     Register rmCondition cc=Always;
    MOZ_ASSERTjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    int32_t   / Float registers can only be loaded/stored in continuous runs when using
    int32_t offset = 0;
    // Build up a new set, which is the sum of all of the single and double
    // registers. This set can have up to 48 registers in it total
    // s0-s31 and d16-d31
    FloatRegisterSet  setreduceSetForPush

    RegisterIteratoriter(od)
    while (iter.more()) {
     (ls rm ,);
      int32_t reg = (*iter).code();
      do {
        offset += delta;
        if ((*iter      return transferMultipleByRunsImpl<FloatRegisterForwardIterator(
          offset +=delta;
        }
        transferFloatReg(*iter);
      } while ((++iter).more() && int32_t((*iter).code()) == (reg += sign));
      finishFloatTransfer();
    }
    return offset;
  }
};

class MacroAssembler;

class MacroAssemblerARMCompat : public MacroAssemblerARM {
 private:
  // Perform a downcast. Should be removed by Bug 996602.
  MacroAssembler& asMasm();
  const MacroAssembler& asMasm() const;

 public:
  ){java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

 public    MOZ_CRASH(Invaliddatatransfer addressing);
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  void j(  void (java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 78
){destAlways;}

  void mov(Register src, Register dest) { ma_mov(src, dest); }
  void mov(ImmWord imm, Register dest) { ma_mov(Imm32                    Register64 out64;
  void mov(ImmPtr imm, Register dest) {
    mov(ImmWord(intptr_t(imm.value)) );
  }
  void mov(odeLabellabel,Register );

  void                      ptrScratchjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    BufferOffset bo  
    addPendingJump(bo, ImmPtr/java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
     scratchasMasm);
    ma_movPatchable(ImmPtr(cint32_t (FloatRegisterSet set, LoadStore ls,
    ma_bx(scratch);
  }
  void branch(const Register reg) { ma_bx(reg); }
  void nop){ma_nop((; }
  void shortJumpSizedNop() { ma_nop(); }
  BufferOffset ret() { return ma_pop(pc
n {
    ScratchRegisterScope(asMasm);
    SecondScratchRegisterScope scratch2(asMasm());
    ma_popn_pc(,scratch, scratch2)
  }
  void push(Imm32 imm) {
    ScratchRegisterScope scratch(asMasm());
    ma_mov(imm, scratch);
    ma_push(scratch);
  }
  void     
void pushImmGCPtr){
    ScratchRegisterScope
    ma_mov(mm java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    ma_push()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  }
   push(constAddress ){
    ScratchRegisterScope scratch(asMasm());
    SecondScratchRegisterScope scratch2         (*)sDouble) java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 9
    scratch)
  }
        finishFloatTransfer)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    if (reg == sp)   }
      ScratchRegisterScope
      (reg scratch)
    } else {
      ma_push(regclass :publicMacroAssemblerARM
    }
  }
  void push(  MacroAssembler& asMasm
    MOZ_ASSERT() simd128 not")java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    ma_vpush(VFPRegister(reg));
  }
  void java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 8
    ScratchRegisterScope
    Imm32  = Imm32(xtraSpacevalue+4)
    ma_dtr(  / Jumps + other functions that should be called from non-arm specific
  }
voidpushWithPaddingImm32   Imm32extraSpace{
      jLabel*dest {(dest java.lang.StringIndexOutOfBoundsException: Range [45, 41) out of bounds for length 45
    SecondScratchRegisterScope scratch2(asMasm());
    Imm32 totSpace = Imm32(extraSpace.value + 4);
    i, scratch);
    ma_dtr(  void mov(ImmPtr, dest){
  }

  void pop(Register reg)  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  void pop(FloatRegister reg) {
    MOZ_ASSERT(reg.isFloat(),  void (JitCode* c) {
    ma_vpop(VFPRegister(reg));
  }

 popN reg){
    ScratchRegisterScope scratch(asMasm());
    Imm32     (bo c) RelocationKindJITCODE);
    ma_dtr(IsLoad,sp totSpace,reg scratch,PostIndex);
  }

  CodeOffset toggledJump(Label* label);

  // Emit a BLX or NOP instruction. ToggleCall can be used to patch thisscratch;
  // instruction.
  CodeOffset toggledCall   branch(const Register reg) { ma_bx(reg); }

  CodeOffset pushWithPatch(mmWordimm){
    ScratchRegisterScope nop() {ma_nop(); }
    CodeOffset label = movWithPatch(imm, scratch);
ma_pushscratch);
    return BufferOffsetret) {return (pc) }
  }

  CodeOffset movWithPatch(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 22
(Imm32imm.),,;
    return     (()
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   imm, Register dest) {
    ma_pushscratch;
  }

  void jump( java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  void jump(JitCode* code) { branch(code  void push( imm {
  void jump(ImmPtr ptr) {
    ScratchRegisterScope scratch ma_pushs);
}
    ma_bx(scratch);
}
  void jump(TrampolinePtr code)     scratch(asMasm()java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
ister){ma_bx(eg);}
  void jump(    ma_push(scratch
    ScratchRegisterScope scratch(asMasmvoid push(Register reg) {
    SecondScratchRegisterScope java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 20
    ma_ldr(addr, scratch,      ScratchRegisterScope scratch(asMasm());
    ma_bx(scratch);
java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 3

  void    
  void test32(Register lhs void ( reg) {
voidtest32Register lhs, Imm32 imm) {
    ScratchRegisterScope scratch(asMasm());
    ma_tst(lhs, imm, scratch);
  }
  void test32(const Address& addr  }
    ScratchRegisterScope   pushWithPaddingRegister reg, constImm32 ) {
    SecondScratchRegisterScope scratch2(    Imm32 totSpace = Imm32(extraSpace.value
    ma_ldr(addr, scratch, scratch2);
    ma_tst(scratch, imm, scratch2);
  }
  void testPtr(Register lhs, Register rhs) { test32(lhs, rhs); }

  void splitTagForTest(const ValueOperand& value, ScratchTagScope& tag) {
    MOZ_ASSERT(value.typeReg() == tag);
  }

  // Higher level tag testing code.
  Condition testInt32(Condition cond, const ValueOperand& value);
  Condition testBoolean(Condition cond, const ValueOperand& value);
  Condition testDouble(Condition cond, const ValueOperand& value);
  Condition testNull(Condition cond, const ValueOperand& value);
  Condition testUndefined(Condition cond, const ValueOperand& value);
  Condition testString(Condition cond, const ValueOperand& value);
  Condition testSymbol(Condition cond, const ValueOperand& value);
  Condition testBigInt( void pushWithPadding(Imm32 imm, const Imm32 extraSpace) {
  Condition testObject(Condition , constValueOperand& value);
  Condition testNumber(Condition cond, const ValueOperand& value);
  Condition testMagic(Condition cond,     Imm32 totSpace = Imm32(extraSpace.value  (xtraSpace. +)

  Condition testPrimitive(Condition cond, const    ma_mov(imm, scratch)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  Condition testGCThing(Condition cond, const ValueOperand& value)  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  // Register-based tests.
  Condition testInt32(Condition  Register tag)
  Condition testBoolean(Conditioncond Register tag)
  Condition     (reg)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   testUndefined(onditioncond  tag)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  (Condition cond, Register tag);
  Condition testSymbol(Condition cond, Register tag);
  Condition testBigInt(Condition cond, Register tag);
   testObjectcond  tag)
  Condition (Condition,java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  Condition java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
  Condition testMagic(Condition cond, java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 17
  , Registertag;
  Condition testGCThing

  Condition testGCThing(Condition cond, const Address& address);
  ConditiontestMagic( cond,  &;
  Condition testInt32()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
testDouble(, const )
  Condition testBoolean       ma_movPatchableIimmvalue,dest,)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  Condition testNull
  (Condition , constjava.lang.StringIndexOutOfBoundsException: Range [57, 55) out of bounds for length 66
   (, Address ;
  Condition testSymbol(Condition cond, const Address& address);
  Condition testBigInt(Condition
  Condition testObject(Condition cond, const & address);
  Condition testNumberCondition,const Address& address);

  Condition testUndefined(Condition cond   ImmPtr ptr java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  Condition testNull    scratch;
  Condition testBoolean(Condition cond, constjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  Condition testString(Condition cond, constvoidjump( ){ r) }
  Condition testSymbol(Condition cond, const     java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 43
  Condition testBigInt(Condition    ma_bxscratch;
  Condition testInt32(Condition cond, const BaseIndex  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   (   java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 61
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 60
  Condition      ((;

  // Unboxing code.
   unboxNonDouble(constValueOperand&,  dest,
                      JSValueType type);
  void unboxNonDouble    ScratchRegisterScopescratch(sMasm);
  void unboxNonDoubleSecondScratchRegisterScopescratch2(sMasm()java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  void java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3
    (,dest JSVAL_TYPE_INT32;
  }
  void unboxInt32(const Address& src
boxNonDouble(src, dest JSVAL_TYPE_INT32;
  }
  voidunboxInt32const BaseIndex& src,  dest){
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  }
void&src,Register dest) {
    unboxNonDouble(src, dest, JSVAL_TYPE_BOOLEAN);
}
  void unboxBoolean(const Address& src, Register dest) {
    unboxNonDouble(src, dest, JSVAL_TYPE_BOOLEAN);
  }
  void unboxBoolean(const   Condition testDouble(Condition const &value);
rc, dest, JSVAL_TYPE_BOOLEAN)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  }
  void unboxString(  Condition testStringCondition & value;
, )java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 dest
    unboxNonDouble(src, dest  testNumberCondition    ValueOperand&value)
  }
  void unboxSymbol  ConditiontestSymbolCondition  Register;
    unboxNonDouble(src, dest, JSVAL_TYPE_SYMBOL);
  }
  void unboxSymbol(const Address& src, Registertag;
    unboxNonDouble(src, dest, JSVAL_TYPE_SYMBOL);
  }
     (ondition  );
    unboxNonDouble(src, dest  testNumberC cond,Register );
  }
  void unboxBigInt(const Address& src, Register  (Condition cond, )java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    
  Condition( cond, const Address address)
 void unboxObjectconst ValueOperand&src,Register dest){
    unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);
  }
  voidunboxObjectconst Address&src, Registerdest) {
    unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);
  }
void (const&src Register dest java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);

  Condition(Condition, Address& address);
  void unboxDouble(const AddressCondition (Condition, constAddress&address)
  void unboxDoubleconst &src,FloatRegister)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

     cond  Address&address);

4.h.
  void unboxGCThingForGCBarrier(const java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 0
ToPayload() )
  }
void(const &,Registerdest) java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    if (src.payloadReg  testString(Condition, &src;
      ma_movsrc.() dest)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    }
  }

  void Condition testObject cond,BaseIndex )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    load32(ToPayload(src), dest);
    {
      ScratchRegisterScope scratch(  Condition testGCThing(Condition cond&src);
      ma_and(Imm32(wasm::AnyRef::GCThingMask), dest, scratch);
    }
  }

  void                   java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 40
    ScratchRegisterScope scratch(asMasm());
    ma_and(Imm32(wasmvoid(onstBaseIndex java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 77
  }

  void notBoolean(const ValueOperand& val) {
.payloadReg,1)
  }

 template typename T>
void(const &src  java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                            Label* fail);

  // Boxing code.
 ValueOperand& ,)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  voidvoid( ValueOperand  ){
 Register srcconstValueOperanddest)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75

  // Extended unboxing API. If the payload is already in a register, returns
  // that register. Otherwise, provides a move to the given scratch register,
 that
  [[nodiscard    unboxNonDoublesrc ,);
                                    scratch)
  [[nodiscard]] Register extractObject(const ValueOperand& value,
                                       Register scratch) {
    unboxNonDouble(value, value.payloadReg(), JSVAL_TYPE_OBJECT);
    return value.payloadReg();
  }
  [[nodiscard]] Register extractSymbol(const ValueOperand}
                                       void (constAddress   ){
    unboxNonDouble(value, value.java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 3
    return value.payloadReg();
  }
  [[nodiscard]] Register extractInt32(  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
                                      Register scratch) {
    java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  }
  [[nodiscard]] Register java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 3
                                        Register scratch) {
    return value unboxObject(&,Register ){
  }
  [[nodiscard]] Register extractTag(const Address& address, RegistervoidconstAddress&src Register )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  [nodiscard] (const BaseIndex& address, Register scratch);
  [[nodiscard]] Register extractTag(const ValueOperand& value,
                                    Register scratch) {
    return value.typeReg();
  }

voidloadInt32OrDouble(const Address& src, FloatRegister dest);
  void loadInt32OrDouble(   unboxDouble(onst & src, FloatRegisterdest)
int32_t  ;
  void loadConstantDouble(double dp, FloatRegister dest);

  // Treat the value as a boolean, and set condition codes accordingly.
  Condition testInt32Truthy(bool truthy, const ValueOperandvoid (const Address&src, egisterdest){
   testBooleanTruthybool truthy,  & operand;
  Condition testDoubleTruthy(bool   void unboxGCThingForGCBarrier(const ,Register){
  Condition      (rcpayloadReg)!=dest){
  Condition testBigIntTruthy(bool truthy, const ValueOperand& value      ma_movs.ayloadReg)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

float,destjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

  (Addressaddress type  dest java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    if (dest.isFloat()) java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 5
      (address,dest()java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    } else {
      ScratchRegisterScopeasMasm(;
      ma_ldr(address      
    }


voidloadUnboxedValue(aseIndexaddress  type  dest)
    if (dest.isFloatjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
e, address.index dest.fpu,address.scale;
    } else {
      load32(address, dest.gpr());
    }
  }

  void storeValue(ValueOperand val, const Address
  void storeValueF&, FloatRegister;
  void storeValue(JSValueType type, Register reg, BaseIndex dest) {
   ScratchRegisterScope (();
    SecondScratchRegisterScope scratch2(asMasm());

int32_t payloadoffset .offset +;
    int32_t typeoffset = dest.offset  // that register. Otherwise, provides a move to the given scratch register,

    ma_alu(dest.base, lsl(dest.index, dest.                                       Register

    // Store the payload.
    if (payloadoffset < 4096 && payloadoffset > -4096) {
      ma_str(reg, DTRAddr payloadReg
    } else {
      (Addressscratch, payloadoffset), scratch2);
    }

    // Store the type.
    if (typeoffset < 4096&& typeoffset > -4096) {
      // Encodable as DTRAddr, so only two instructions needed.
      ma_mov(ImmTag(JSVAL_TYPE_TO_TAG(type)), scratch2);
      (typeoffset)));
    } else {
      // Since there are only two scratch registers, the offset must bevalue();
      // applied early using a third instruction to be safe.
      (mm32(),scratch, scratch2);
      ma_mov(ImmTag(JSVAL_TYPE_TO_TAG(type)), scratch2);
      ma_str(scratch2, DTRAddr(scratch, DtrOffImm(0)));
    }
  }
  void storeValue(JSValueType}
     (()java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    SecondScratchRegisterScope scratch2(asMasm());

    ma_str(reg, dest, scratch2);  [nodiscard]]Register( &address  )java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
    ma_mov(ImmTag(JSVAL_TYPE_TO_TAG(type)), scratch);
    ma_str(scratch, Address(dest.base, dest.offset + NUNBOX32_TYPE_OFFSET),
           scratch2);
  }
  void storeValue(const ValueRegister scratch)
    ScratchRegisterScope scratch(asMasmreturnvaluetypeReg();
    SecondScratchRegisterScope scratch2(java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 3

    ma_mov java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 75
    ma_str(scratch, ToType(dest),                          int32_t shiftdefaultShift;
    if (val.isGCThing()) {
ma_mov(ImmGCPtr(aljava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 49
  
      ma_mov(Imm32(val.toNunboxPayload()), scratch);
    }
    ma_str(scratch, ToPayload(dest), scratch2);
  }
  void(constValue val, BaseIndex dest){
    ScratchRegisterScope scratch(asMasm());
pescratch2(sMasm()java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

    int32_t typeoffset = dest.offset + NUNBOX32_TYPE_OFFSET;
    int32_t payloadoffset =dest.+;

    ma_alu(dest.base( f ;

    // Store the type.
     (ypeoffset <4096 &typeoffset -4096) {
      ma_mov(Imm32(val.toNunboxTag()), scratch2);
      ma_str(scratch2, java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 25
          ScratchRegisterScope(asMasm);
      ), scratch, scratch2);
      ma_mov(Imm32(val.toNunboxTag()), scratch2);
      ma_str(}
      
      ma_aludestbase, lsld., dest.cale,scratch,OpAdd
    }

   // Store the payload, marking if necessary.
    if (    } else java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
      if (val.isGCThing()) {
        ma_mov(ImmGCPtr(val. storeValuejava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 56
      }   void storeJSValueType  reg java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 67
        ma_mov(Imm32(al.toNunboxPayload(), scratch2);
      }
      ma_str(scratch2, DTRAddr(scratch, DtrOffImm(payloadoffset)));
    } elsejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      ma_add(Imm32(payloadoffset) scratch, scratch2);
      if (val.isGCThing()) {
        ma_mov(ImmGCPtr(val.toGCThing()), scratch2);
      } else {
        ma_mov((valtoNunboxPayload()), scratch2);
      }
      ma_str(scratch2, DTRAddr(scratch, DtrOffImm(0)));
    }
  }
  void storeValue(const Address& src, const Address& dest, Register temp
    load32(ToType(src),     if (payloadoffset < 4096(  4096&java.lang.StringIndexOutOfBoundsException: Range [49, 45) out of bounds for length 56
    store32(temp, ToType(dest));

load32(oPayload) temp);
    store32(temp, ToPayload(dest));
  }

  void storePrivateValue// Store the type.
   store32(0) ToType(dest));
    store32(src, ToPayload(dest));
  }
  void       // Encodable
    store32(Imm32(0), ToType(dest));
    storePtr(imm, ToPayload(dest))java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  }

  void    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  void loadValue      // applied early using a third instruction to be safe.
    loadValue(dest.toAddress(), val);
  }
&addr,ValueOperand);


  // don't support unaligned accesses).
voidloadUnalignedValueconstAddress&,ValueOperand )java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

voidtagValue(JSValueType type, Registerpayload,ValueOperand dest) {
    boxNonDouble(type, payload, dest);
  }

  void pushValue(ValueOperand val);
  void ( val;
  void pushValue(const 
pushI(val))java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    if (val.isGCThing() ma_str(,Addressdestbase, offset +NUNBOX32_TYPE_OFFSET,
      push(ImmGCPtr(val.  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

      push(Imm32(val.toNunboxPayload()));
    }
  }
  void pushValue(JSValueType type, Register
pushImmTag(JSVAL_TYPE_TO_TAG(type)));
    ma_push(reg);
  }
ress addr)
  void     if (valisGCThing()) {

  void storePayload(constValue val, const Address& dest);
  void storePayload(Register src, const Address}else{
  void storePayload(const Value&      (Imm32(val.toNunboxPayload()), scratch);
  void storePayload(Register src, const BaseIndex& dest)    }
  void storeTypeTag(ImmTag tag const & dest);
  void storeTypeTag(ImmTag tag, const BaseIndex& dest);

  voidjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 43
                                    int32_t typeoffset = dest.offset + NUNBOX32_TYPE_OFFSET;

  /////////////////////////////////////////////////////////////////
  .
  /////////////////////////////////////////////////////////////////
     /Store thetype.
  void not32(Register reg);

void move32(Imm32 imm,Register dest);
  void move32(Register src, Register dest);

  java.lang.StringIndexOutOfBoundsException: Range [14, 6) out of bounds for length 44
  void movePtr(ImmWord imm, Register dest);
  void movePtr(ImmPtr imm, Register dest);
  void movePtr(wasm::SymbolicAddressma_add(Imm32(ypeoffset),scratch,scratch2);
  void movePtr(ImmGCPtr imm, Register dest);

  FaultingCodeOffsetma_str(, DTRAddrscratch, DtrOffImm(0)));
  FaultingCodeOffset load8SignExtend(const BaseIndex& src, Register dest);

  FaultingCodeOffset       ma_alu(dest.base, lsl(dest, dest.scale), scratch,OpAdd);
  FaultingCodeOffset load8ZeroExtend(const BaseIndex& src, Register dest);

FaultingCodeOffsetload16SignExtend(Address& address Registerdest)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
FaultingCodeOffsetload16SignExtend(const BaseIndex& src, Register dest);

  ma_movI(altoGCThing java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  void load16UnalignedSignExtend(const
/java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    load16SignExtend(src, dest);
  }

        if val.isGCThing(){
  FaultingCodeOffset load16ZeroExtend(const BaseIndex& src, Register dest);

          java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        scratch2DTRAddrscratch())java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    // load16ZeroExtend uses |ldrh|, which supports unaligned access.storeValue( Address ,constAddress& dest, Register temp) {
    load16ZeroExtend(src, dest)
  }

  FaultingCodeOffset load32(const Address& address, Register 
  FaultingCodeOffset load32(const BaseIndex& address, Register dest);
  void  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  template <typename S>
  load32Unaligned(const S& src, Register dest) {
    // load32 uses |ldr|, which supports unaligned access.store32(rc, ToPayload(dest);
    load32(src, dest);
  }

  FaultingCodeOffsetPair load64(const Address& address, Register64 dest) {    store32(mm32() ToType(dest));
    FaultingCodeOffset fco1, fco2;
.base= dest.low;
    if (highBeforeLow) {
=HighWordaddressdest)
      fco2 = load32(LowWord(address),   void loadValue(Operand dest, ValueOperand
    }else
      fco1= load32(LowWord(address), dest.low);
      fco2 = load32(HighWord(address), dest.high);
    }
    return FaultingCodeOffsetPair(fco1, fco2);
  }
  FaultingCodeOffsetPairload64(constBaseIndex& address, Register64 dest) {
    // If you run into this, relax your register allocation constraints.
MOZ_RELEASE_ASSERT(
        !((address.base == dest.low || address.base ==   void loadUnalignedValue(const Address& ;src, ValueOperand
          (address   tagValueJSValueType type, Register payload, ValueOperand dest) {
    FaultingCodeOffset     boxNonDouble, payload, dest);
    bool highBeforeLow =
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 24
      pushValueconst Value&){
fco2= load32LowWord(ddress) dest.ow)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

      fco1 =       push(mmGCPtr(toGCThing));
      fco2 = load32(HighWord(address),       push(Imm32(val.toNunboxPayload()))
    }
    return     push(ImmTag(SVAL_TYPE_TO_TAGtype))java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
}

  template <typename S>
    void( &java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    // load64 calls load32, which supports unaligned accesses.
    load64(src, dest);
  }

  FaultingCodeOffset loadPtr(const Address  ( &  java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 61
(  java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 66
  void loadPtr(AbsoluteAddress address, Register dest
);

voidconst& java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 58

  /////////
  java.lang.StringIndexOutOfBoundsException: Range [22, 11) out of bounds for length 22

  FaultingCodeOffset loadFloat32(const Address& java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 0
  FaultingCodeOffset loadFloat32(const BaseIndex& src, java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 43

  FaultingCodeOffset loadFloat16(const Address   movePtrRegister  dest);
                                  )
  FaultingCodeOffset loadFloat16(const BaseIndex& src, FloatRegister dest,
                                 Register scratch);

  FaultingCodeOffset store8
  voidstore8Imm32imm,constAddress );
  FaultingCodeOffset store8(Register src, const BaseIndex& address);
  void store8(Imm32 imm, const BaseIndex& address);

   c  ,Registerjava.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 74
  voidstore16( const Address&address)
     load16SignExtend &srcRegisterdestjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  void store16nload16UnalignedSignExtend &src  dest java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

  template <typename S, typename T>
  void store16Unaligned(const S&   (constAddress  dest;
    // store16 uses |strh|, which supports unaligned access.
    store16(src, dest);
  }

e32 src, AbsoluteAddress address);
     load16UnalignedZeroExtend S ,java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 63
  FaultingCodeOffset     load16ZeroExtend(src, dest)
  void store32(Imm32 src, const Address&
   store32(Imm32src const & address)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

  template <typename S, typename T>
  void store32Unaligned(const S& src, const T& dest) {
    // store32 uses |str|, which supports unaligned access.
    store32(src, dest);
java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 3

ir(Register64   {
    FaultingCodeOffset fco1 = store32(src.low, LowWord(address));
    FaultingCodeOffset fco2 = store32(src.high, HighWord(address  FaultingCodeOffsetPair load64(const Address& address, Register64 dest) {
    return FaultingCodeOffsetPair(    bool highBeforeLow = address.base .low;
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  FaultingCodeOffsetPair java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    FaultingCodeOffset       fco2 = load32(HighWor,high;
     FaultingCodeOffsetPair)
    returnFaultingCodeOffsetPairBaseIndex Register64dest java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  }

  voidImm64imm  address){
    store32(imm.low(), LowWord(address));
    store32(imm.hi(), HighWord( FaultingCodeOffsetfco1 fco2;
  }

address 
          fco2 LowWord(address), dest.low);
    store32(imm.hi(), HighWord(address));
  }

  template <typename S, typename T>
  void store64Unaligned(const S& src,        =load32(HighWord(), dest;
    // store64 calls store32, which supports unaligned access.
    store64(src, dest);
  }

 Address& address);
  void storePtr(ImmWord java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 3
 ImmPtrjava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 52
  void storePtr(ImmPtr imm    / load64 calls load32, which supports unaligned accesses.
voidstorePtr(mmGCPtrimm, Address;
  void java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 70
  void storePtr(Register   void loadPtr(AbsoluteAddre java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 55

  void void loadPrivate(const Address& address, Register dest);
Condition= java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    ma_vmov(src, dest, cc);
  }

  inline void incrementInt32Value(const Address& addr);

  void cmp32(Register lhs, Imm32 rhs)
  void cmp32( lhs,Register rhs);
  void cmp32(const Address& lhs, Imm32 rhs);
  void cmp32(const Address& lhs, Register rhs);

   rhs);
  void cmpPtr(Register lhs, ImmWord rhs)                                  scratch);
  void cmpPtr(
void cmpPtr(Register lhs, ImmGCPtr rhs);
  void    store8Imm32imm,const Address&address)
& lhs, egister rhs);
  void cmpPtr(const Address& lhs, ImmWord rhs);
void cmpPtr(const Address&lhs )
  void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  void cmpPtr(const Address& lhs, Imm32 rhs);

  template <typename T1, typename T2>
  inline void cmp64SetAliased(Condition cond, T1 lhs, T2 rhs, Register dest);

  template <typename T1, typename T2>
  inline void cmp64SetNonAliased  template typename S, typename T>

  template <typename T1, typename T2>
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
                           Label* fail)

  void   store32,  java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 67

  void breakpoint();
  // Conditional breakpoint.
  void breakpoint(Condition cc);

 simulator'sinteractive read-eval-print loop.
  // The message will be printed at the stopping point.
  // (On non-simulator builds, does nothing.)


  void minMax32(Register lhs, Register rhs, java.lang.StringIndexOutOfBoundsException: Range [0, 52) out of bounds for length 23
  void minMax32(  FaultingCodeOffsetPair( src Address address address){

  // Evaluate srcDest = minmax<isMax>{Float32,Double}(srcDest, other).
  // Checks for NaN if canBeNaN is true.
  void minMaxDouble( java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
                    bool isMax);
  void(FloatRegistersrcDest  other,boolcanBeNaN,
                     bool isMax);

   lhs, FloatRegisterrhs);

  void compareFloat(FloatRegister lhs, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  void     store32(imm.low(),LowWord(address);

  void   }
    ma_mov(Imm32(0), dest
ma_mov(1) ,);
  }

NullSetcond,const&value Register dest {
    cond =    immhi) address)
    emitSet(cond, dest);
  }

  void testObjectSet(Condition cond,   void store64Unaligned(const S& src, const){
    cond = testObject(    // store64 calls store32
    emitSet(cond, dest;
  }

Operand java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  ,Address )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    cond = testUndefined(condond )
    emitSet(  ImmGCPtrimm,const&address);
  }

 protected:
  buildOOLFakeExitFramevoid )java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

 public:
s,  java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
asMasm
            cc java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  void computeEffectiveAddress  Register rhs
   ScratchRegisterScope scratch(asMasm();
    ma_alu(address.base, lsl(address.index, address.scale), dest, OpAdd,
           LeaveCC);
    if (address.offset) {
s.offset,dest,scratch )java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    }
  }
  void floor(FloatRegister input, Register output, Label* handleNotAnInt);
  void floorf(FloatRegister input, Register output, Label* handleNotAnInt);
  void ceil(FloatRegister input, Register output, Label* handleNotAnInt);
  void ceilf(FloatRegister input, Register output, Label* handleNotAnInt);
 output, Label* handleNotAnInt,
             FloatRegister tmp);
voidroundf(FloatRegister input, Register output, Label* handleNotAnInt,
)
  void   ( ,;
  void   (const Address lhs,ImmPtrrhs);

  void lea(Operand addr, Register dest) {
ScratchRegisterScope (asMasm));
    ma_add(addr.baseReg(), Imm32(addr.disp
  }

void abiret  as_bx(); }

  void moveFloat32(FloatRegister src, java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 37
                   Conditioncc=Always {
    as_vmov(VFPRegister(dest).java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
            cc);
  }

  // Instrumentation for entering and leaving the profiler.
( framePtr  scratch;
    ( cc)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
};

 java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

}  // namespace jit
}  // namespace js

#endif /* jit_arm_MacroAssembler_arm_h */