MacroAssembler-arm.h   Interaktion und
PortierbarkeitC

/* 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/. */

#jitarm-rm
#define#include "jit/MoveResolver.h"

#include "mozilla/DebugOnly.h"

#include "jit/arm/Assembler-arm.h"
#include "jit/MoveResolver.h"
#include "vm/BytecodeUtil.h"
#include "wasm/WasmBuiltins.h"
#include "wasm/WasmCodegenTypes.h"

using js::wasm::FaultingCodeOffsetPair;

namespace js {
namespace jit {

static Register CallReg = ip;
static const int defaultShift = 3;
static_assert(1 << defaultShift == sizeof#include "vm/BytecodeUtil"

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

class ScratchTagScope {
  const ValueOperand& v_;

 public:
  ScratchTagScope(MacroAssembler&, const ValueOperand& v) : v_(v) {}
  operator Register(){ return v_.typeReg(;}
   release) {java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  void reacquire() {}
};

class ScratchTagScopeRelease {
 public:
  explicit
};

// MacroAssemblerARM is inheriting form Assembler defined in
// Assembler-arm.{h,cpp}
class // MacroAssembler-x64.h.
 private:
  // Perform a downcast. Should be removed by Bug 996602.
  const ValueOperand;
   public:

 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 overriderelease(){}
  / this though, since baseline IC stubs rely on lr holding the returnjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  // address.
  Register secondScratchReg_; :

public
  Register getSecondScratchRegMacroAssemblerasMasm;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  // Higher level tag testing code.
  // TODO: Can probably remove the Operand versions.
  Operandjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
RegisterFromCode.(,base())java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    Operand(Operandbase) {
  BaseIndex ToPayload(const BaseIndex& base) const {     return Operand(Register::FromCode(base.base()), base.di}

 protected:
  ToPayloadconstBaseIndex& base{return; }
    Operand(Register:FromCodejava.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 51
                   base.dispreturn (Register:FromCode(base.base()),
  }
                   base.disp()  sizeof(*));
    return ToTypeOperand(base)).oAddress)
  }
  BaseIndex ToType(const BaseIndex& base) const {
    return BaseIndex(base.base, java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 3
                     base.offset + sizeof(void     BaseIndexbase.,base, base.,
  }

  Address ToPayloadAfterStackPush(const Address& base) const {
    // If we are based on StackPointer, pass over the type tag just pushed.
    if (base. if(.base= ) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
       Address.base,.java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 61
    }
return)
    ToPayloadbjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

 
)  (lr }

  void setSecondScratchReg(Register reg) {
    MOZ_ASSERT    (reg = ScratchRegister;
    secondScratchReg_ = reg;
  }

    void(Register source Register ;
 src, FloatRegister;
  void convertInt32ToDouble(constvoid (onstAddress src, FloatRegister )
  void& src, FloatRegister dest);
  void convertUInt32ToFloat32(Register src, FloatRegister dest);
  void convertUInt32ToDouble(  void convertUInt32ToFloat32(Register  java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  (src ,
                               c;
  (FloatRegister src, Register dest, Label* fail,
                            bool negativeZeroCheck = true);
 voidconvertDoubleToPtr(FloatRegister src, Register dest, Label* fail,
                          bool negativeZeroCheck = true) {
    convertDoubleToInt32(src, dest, fail, negativeZeroCheck);
  }
  void convertFloat32ToInt32FloatRegister , Register dest, Label*failjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
                             bool negativeZeroCheck = true);

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

  void convertDoubleToFloat16(FloatRegister                              negativeZeroCheck =true;
    convertInt32ToFloat32 src java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 63
  }
  void convertFloat16ToDouble(FloatRegister src, FloatRegister dest) {
    (Not supportedforthistargetjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  }
  void convertFloat32ToFloat16(FloatRegister src,   }
  void convertFloat16ToFloat32(FloatRegister src, FloatRegister dest);
convertInt32ToFloat16  ;

  void wasmTruncateToInt32(FloatRegister input, Register output,
                           fromTypebool ,isSaturating
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 voidoutOfLineWasmTruncateToIntCheck(FloatRegisterinput,MIRType fromType,
                                       MIRType toType, TruncFlags flags,
                                Label rejoin,
                                       const wasm::TrapSiteDesc& trapSiteDesc);

  // Somewhat direct wrappers for the low-level assembler funcitons
/java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  // instructions.
                               isUnsigned isSaturating
  boolalu_dblRegister  imm dest,ALUOp SBits
               Condition c);

 public:
  void ma_alu(                                       MIRTypetoType  flags
              AutoRegisterScope&                                    :&);
              Condition c = Always  // instructions.
voidma_alu(  ,Register,ALUOpjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
              :
voidma_alu(   ,Register,java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
SBits= ,  =)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  void ma_nop();   (,op2,Register ,

  BufferOffset ma_movPatchable(Imm32 imm, Register               s=,  ;
                               Assembler:Condition c)
  BufferOffset ma_movPatchable(ImmPtr imm,               s =LeaveCC,  =;
                               :c;

  // To be used with Iter := InstructionIterator or BufferInstructionIterator.
  template <lassIter>
  static void ma_mov_patch(Imm32 imm,   BufferOffset ma_movPatchable(ImmPtr imm dest,
                           RelocStyle java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 0

  // ALU based ops
  // mov
java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
              Condition c = Always

   (mm32, , c =);
  void ma_mov(ImmWord imm, Register dest, Condition c = Always);

  ma_movI , )

    void ma_mov(ImmWord imm, Register dest, Condition c = Always);
Imm32 , , );
  void ma_lsr(Imm32 shift, Register
  void ma_asr(  void ma_lsl(Imm32( shift,  dst;
  void  R  java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 55
  void ma_rol(Imm32 shift, Register src)

  void ma_lsl(java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
  void ma_lsr(Register   shiftjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 58
  void ma_asr(Register shift,  java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 58
void( java.lang.StringIndexOutOfBoundsException: Range [42, 38) out of bounds for length 58
  void ma_rol(Register AutoRegisterScope;
              & )


  void ma_mvn( c=Always;
              Condition c = Always);

    // Negate (dest <- -src) implemented as rsb dest, src, 0
  void ma_neg(Register src, Register dest  R ,   =,
              Condition c =               Condition c = Always

  

/ 
  void              java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 36
               c=java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 36

  void ma_and
               Always;

 dest,& ,
              SBit s = LeaveCC

  void ma_and(Imm32 imm, Register               AutoRegisterScope& scratch =
              AutoRegisterScope , s=,
              Condition c = Always);

  // Bit clear (dest <- dest & ~imm) or (dest <- src1 & ~src2)
  void ma_bic(Imm32 imm, Register dest, AutoRegisterScope& scratch,
              SBit s = LeaveCC, Condition c = Always);

  // Exclusive or
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
              Condition c = Always);

  void ma_eor
               c = Always);

  void ma_eor(Imm32 imm, Register dest,               c =Always);
              ondition c = Always);

  void ma_eor(Imm32 imm, Register src1, Register dest,
AutoRegisterScope&scratch, s ,
              Condition c = Always);

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

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

  void ma_orr(Imm32 imm, Register dest, java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 36
               s =LeaveCC java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 54

  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
               ,SBits =LeaveCCjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
              Condition  =)

  // Arithmetic based ops.
  // Add with carry:
  void              java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 59
    java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 54
void( ,Register, java.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 60
  void (egister src Register dest SBit s  LeaveCCjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
voidma_adc(Registersrc1 Register src2, Register dest SBit s =LeaveCC,
              Condition c = Always);
  Condition c = Always);
              AutoRegisterScope& scratch, SBit s = LeaveCC,
              Condition  Always)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

  // Add:
  , Registerdest, AutoRegisterScopejava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
SBit  ,Condition=Always;
  void ma_add(Register src1, SBit s = LeaveCC, Condition;
              Condition c = Always);
  void ma_add(Register src1, Registersrc2, Register dest, SBit s = LeaveCC,
              Condition c = Always);
  void ma_add(Register src1              Condition c = Always);
Condition c java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 36
   opRegister,
AutoRegisterScope SBit s  ,
              Condition c = Always);

  // Subtract with carry:
  void ma_sbc(Imm32 imm, Register dest, AutoRegisterScope& scratch,
              SBit  void ma_add(Register src1,Imm32 , Register dest,
  void ma_sbc              AutoRegisterScope&scratch,SBit s =LeaveCC,
                              = );
  void    ma_sbc(mm32 imm Register dest, AutoRegisterScopescratch,
Condition =);

  // Subtract:
  void   void ma_sbc src1,Register ,SBit  ,
              s=LeaveCC  c = Always);
  void ma_sub(Register src1, Register dest  void (egister java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 76
              Condition   java.lang.StringIndexOutOfBoundsException: Range [27, 22) out of bounds for length 61
Register, src2,Register, java.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 76
Conditionc=Always;
  void ma_sub(Register src1, Operand op, Register dest, SBit s =   void ma_sub(Register src1, Operand op, Register dest, SBit s = LeaveCCOperandop Register dest, SBit s = LeaveCC,
              Condition c              java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 59
  void ma_sub(Register src1  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
                            SBit s = LeaveCCCondition  java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
               c java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

  // Reverse subtract:
  void ma_rsb(Imm32 )
              SBit s = LeaveCC, Condition c   Registersrc1,Imm32, dest,
  void ma_rsbConditionA;
              Condition
  void ma_rsb(  void ma_rsc(Imm32  , 
Conditionc  ;
  void ma_rsb(Register void java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 61
              AutoRegisterScope&ister ,    = LeaveCCjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
              Condition   // Compare negative (sets condition codes as src1 + src2 would):

  // Reverse subtract with carry:
  void ma_rsc(Imm32 imm, Register dest, AutoRegisterScope& scratch,
              SBitConditionc = Always);
  void ma_rsc(egister , Register dest, SBit s = LeaveCC,
                void ma_cmn(Register,  op,  c=Always);
  void ma_rsc(Register src1  void ( src1  imm, AutoRegisterScope&scratch,
              Condition c =                 =Always;

omparestests
     ( ,ImmWord ,AutoRegisterScope scratch,
  void ma_cmn(Conditionc=Always);
              Condition c = Always);
void(Register ,Register , Condition =Always;
  void ma_cmn(Register src1,               c = );

  // Compare (src - src2):
  void ma_cmp(Register src1,               &scratch2Conditionc  )java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
              Condition (rc1^ src2java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  void ma_cmp(Register src1, ImmTag tag              Conditionc = );
  java.lang.StringIndexOutOfBoundsException: Range [59, 6) out of bounds for length 69
              Condition c = Always);
   ptr,AutoRegisterScope ,
              Condition c = Always);
  void ma_cmp(Register src1, Operandjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
              &scratch2  cAlways);
  void ma_cmp(Register src1, Register src2, Condition c =  Condition  =)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

/   equality,( ^src2:
  void ma_teq(Register java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                void ma_mul(Register    Registerdest)
voidma_teq( src1 Register src2,Condition  )java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  void Register, ,Conditionc=Always)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

  // Test (src1 & src2):                         & java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 69
  void ma_tst(Register src1, Imm32                          AutoRegisterScopejava.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 69
                =Always);
  void ma_tst(Register src1, Register src2, Condition c = Always);
  void ma_tst(Register src1, Operand);

  // Multiplies. For now, there are only two that we care about.java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    
  ma_mod_mask ,, ,Register,
              &scratch;
  Condition ma_check_mul(Register src1java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 34
                          scratch  java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 69
  Condition ma_check_mul(Register src1, Imm32  AutoRegisterScope& )
AutoRegisterScope&scratch,Condition condjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

  void ma_umull(Register src1, Imm32   void ma_umull(Register src1, Imm32 imm
                ma_sdiv num Registerdiv  java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  void void ma_udiv num,  ,
                Register destLow);

 scratch, and needs    assembler
  // implicitly assumes that we can overwrite dest at the beginning of the
  // sequence.
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 76
                   /
                   int32_t shift);

  // Mod - depends on integer divide instructions being supported.java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 62
(num ,dest
               AutoRegisterScope& scratch);
  void ma_umod(Register num, Register div, Register dest,
               AutoRegisterScope& java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 0

                                ;
  void ma_sdiv(Register num, Register div, Register dest,
               Condition cond = Always);
  void ma_udiv(Register num, Register div, Register java.lang.StringIndexOutOfBoundsException: Range [76, 56) out of bounds for length 76
               Always);
  // Misc operations
   FaultingCodeOffsetma_ldrsh(EDtrAddraddr,Register rt Indexmode  Offset,
  , AutoRegisterScope&scratch)
  // Memory:
  // Shortcut for when we know we're transferring 32 bits of data.
  void ma_dtr(FaultingCodeOffset(addr, Register  mode  java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
                void ma_ldrd(EDtrAddr addr rt :<egister> rt2,
              Condition cc = Always);
FaultingCodeOffsetLoadStore,  ,  &addr,
                            AutoRegisterScope& scratch, Index mode,
Condition ;

  FaultingCodeOffset ma_str(Register rt, DTRAddr Condition= );
   ma_strhRegister ,java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 77
FaultingCodeOffsetma_strRegister rt   
                            AutoRegisterScope& scratch, Index mode =   (java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 76
                            Condition cc = Always);

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

  FaultingCodeOffset ma_ldrb(DTRAddr addr, Register rt, Index mode = Offset,
                             Condition ;
  FaultingCodeOffset ma_ldrh(EDtrAddr addr, Register rt, Index mode = Offset,
                             Condition cc = java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0
  FaultingCodeOffset                                 Register rn, Register , Register rt,
                              Condition cc =                                 mode = Offset, Condition cc = Always);
   ma_ldrsb(DtrAddr,Register ,Indexmode  ,
                              Condition cc = Always);
  void ma_ldrd(EDtrAddr addr, Register AutoRegisterScopejava.lang.StringIndexOutOfBoundsException: Range [73, 65) out of bounds for length 80
               Index  BufferOffset ma_pop(Register r);
    void ma_popn_pcImm32 n AutoRegisterScope& scratch
                             Condition cc=Always;
  FaultingCodeOffset ma_strh(Register rt, EDtrAddr addr, Index mode = Offset,
                             Condition = Always));
  void ma_strd(Register rt, mozilla::DebugOnly<Register  void ma_push_sp(egister r,AutoRegisterScope& scratch);
               Index mode  void ma_vpopVFPRegister r);

  // Specialty for moving N bits of data, where n == 8,16,32,64. ma_vpush(VFPRegister r);
  BufferOffset ma_dataTransferN(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
                                rn Register rm,Register rt,
                                e& scratch Index mode = Offset,
                                Condition cc = Always, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  BufferOffset ma_dataTransferN   *c ;
                                Register (Register,c=Always)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                                Index   (     )

  BufferOffset ma_dataTransferNjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
Register,Imm32 offset rt
                                AutoRegisterScope& scratch, Index mode = Offset,
                                Condition cc = Always);

  BufferOffset ma_pop(Register r);
, AutoRegisterScope& scratch,
                  AutoRegisterScope& scratch2);
 r)
  void ma_push_sp(Registerjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  void ma_vpop(VFPRegister r);
  (VFPRegister r)

  // Barriers.
  void ma_dmb(BarrierOption                    Condition cc = 
  void ma_dsb(BarrierOption option = BarrierSY);

 / Branches when done from within arm-specific code.
  BufferOffset ma_b                    cc=Always)

  void ma_bx(Register dest,   void ma_vsqrt_f32(FloatRegister srcFloatRegister,java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 58

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

  void ma_blx(Register dest, Condition c = Always);

  / VFP/ALU:
void ma_vaddFloatRegistersrc1 FloatRegistersrc2, dst;
  void ma_vsub(FloatRegister src1, FloatRegister src2,                    ccAlways);

  void ma_vmul(FloatRegister src1, FloatRegister src2, FloatRegister dst)  ma_vcmpz_f32( src1, Condition  =Always);
void FloatRegister, FloatRegister ,FloatRegister);

  void ma_vneg(FloatRegister src, FloatRegistervoid java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 78
  void ma_vmov(FloatRegister src,FloatRegister , cc=Always)
  void ma_vmov_f32(FloatRegister src, FloatRegister dest,
                   Condition cc = Always);
  void
 ma_vabs_f32(loatRegistersrc,FloatRegister dest,
                                       cc= )

  void   ma_vcvt_F64_I32( src,FloatRegisterdest,
   ( ,FloatRegisterdest,
                    Condition cc = Always);

  void ma_vcvt_F64_U32src FloatRegister dest,
  void ma_vimm_f32(float value, FloatRegister dest,

ma_vcmpF src1,java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 78
  void ( src1,FloatRegistersrc2,
                   Condition cc = Always);
 Always);
  void ma_vcmpz_f32(java.lang.StringIndexOutOfBoundsException: Range [61, 36) out of bounds for length 61

  void ma_vadd_f32(FloatRegister src1   (loatRegister, FloatRegisterdest,
, src2,FloatRegisterdst)

  void void ma_vcvt_U32_F32java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 61
  void ma_vdiv_f32(FloatRegister 

  ,
                   Condition  a  into ofjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

  // Source is F64, dest is I32:
 ,java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
                     Condition cc =);
voidma_vcvt_F64_U32(loatRegistersrc,FloatRegister,
                       Condition java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0

  // Source is I32, dest is F64:
void(FloatRegistersrc,FloatRegister,
                       Condition cc = Always);
  void ma_vcvt_U32_F64(FloatRegister src, FloatRegister dest,
                       Condition  =Always);

  // Source is F32, dest is I32:
void (FloatRegistersrc FloatRegister dest,
                                              AutoRegisscratchConditionjava.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 74
ma_vcvt_F32_U32  
                       Condition                         )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

  // Source is I32, dest is F32:
  void ma_vcvt_I32_F32AutoRegisterScope  cc ;
                       BufferOffset src base index,
java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 61
                       Condition cc = Always);

  // Transfer (do not coerce) a float into a gpr.
  void ma_vxfer(VFPRegister src, RegisterAutoRegisterScopeshift
  // Transfer (do not coerce) a double into a couple of gpr.
, Registerdest1 dest2
                Condition cc = Registerrm DTMModemode java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

  // Transfer (do not coerce) a gpr into a float
  void       <>
  // Transfer (do not coerce) a couple of gpr into a double
  void ma_vxfer(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 21
                   )

  BufferOffset ma_vdtr(LoadStore ls, const Address& addr, VFPRegister dest,
                       AutoRegisterScopescratch  cc =;

BufferOffset ( addr, VFPRegisterdest Condition cc= Always
  BufferOffset   // `outAny` is valid  only o =Register64:nvalid).
                         void wasmLoadImplc :&access Register 
  BufferOffset ma_vldr(VFPRegister src, Register base, Register index,
                       AutoRegisterScope& scratch, int32_t                     out64)
                       Condition cc = Always);

  BufferOffset ma_vstr(VFPRegister src, VFPAddr addr, Condition cc = Always);
  
                       AutoRegisterScope& scratch, Condition cc = Always);
  BufferOffset ma_vstr(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                       AutoRegisterScope& scratch, AutoRegisterScope& scratch2,
                       int32_t shift, int32_t  
     <ypenameRegisterIterator
AutoRegisterScope&scratch,int32_t java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                         Always)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

  void ma_call(ImmPtr dest);

/java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  // 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 transferMultipleByRuns(    FloatRegisterSet mod = set.reduceSetForPushmod =set.();
                                  iterm;
    if (mode == IA startFloatTransferM, ,mode, riteBack
>
          set,=java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
     
    if (mode == DB) {
      return MacroAssemblerARMCompat( }
          set, ls, rm, mode, -1);
    }
    (  transfer mode"
  }

    // code. Basically, an x86 front end on top of the ARM code.
wasmLoadImplconst wasm::MemoryAccessDesc& access, Register memoryBase,
                    Register ptr,                      as_b(, ) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
)

  // `valAny` is valid if and only if `val64` == Register64::Invalid().
      movu(immvalue),dest
                     Register64 val64C*   destjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
Register);

 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 <typename     ScratchRegisterScope(())
   transferMultipleByRunsImpljava.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 72
                                     Register rm,  
    MOZ_ASSERT(sign == 1 || sign  void(  ) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

    int32_t delta n){
    int32_t offset      scratch()java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    // Build up a new set, which is the sum of all of the single and double( , )java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    // registers. This set can have up to 48 registers in it total
// s0-s31 and d16-d31
    FloatRegisterSet mod   push( imm 

    RegisterIterator    (,scratch);
    while (iter.more()) {
      startFloatTransferM(ls, rm,    scratch;
      int32_t reg = (*iter).code();
      do {  voidpush(const &addr {
        offset += delta;
       if(iter).(){
          offset += delta;
        }
        transferFloatReg(*iter);
      } while ((++iter).more() && int32_t    ma_push(cratch)
      (;
    }
    return offset;
  }
};

class       ma_push_sp,scratch)

 MacroAssemblerARMCompat   {
 private:
  // Perform a downcast. Should be removed by Bug 996602.
();
  const MacroAssemblerMOZ_ASSERT(reg.isFloat," supported";

 public:
  MacroAssemblerARMCompat() {}

 public:    totSpace= (xtraSpace. + 4)
//
  // code. Basically, an x86 front end on top of the ARM code.
  void j   (imm,const ) {
  void (Label*dest){as_b,Always); }

  void mov(Register src, Register dest) { ma_mov(src, java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 50
  void mov(ImmWordma_mov(mm, scratch;
   imm Registerdest 
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
  }
  void mov(CodeLabel 

branch(java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 27
    BufferOffset bo  void(Register, Imm32 extraSpace java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
addPendingJump, ImmPtr(->raw(),::;
    ScratchRegisterScope ,totSpace ,  java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    ma_movPatchable
    ma_bx()java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  }
void( ){
  void nop java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 26
  void shortJumpSizedNop()    ();
   (  ma_pop;java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  void retn(Imm32 n) {
    ScratchRegisterScope     BufferOffset offset = ma_movPatchable(.value dest Always)
    SecondScratchRegisterScopescratch2(asMasm();
    ma_popn_pc(n, scratch  }
  }
  void push(Imm32 imm) {
    ScratchRegisterScope   CodeOffset movWithPatch(ImmPtr ) {
    ma_mov(imm, scratch);
()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
}
  void push(ImmWord imm) { push(Imm32(imm.value)); }
  void ImmGCPtr ){
    ScratchRegisterScope scratch(asMasm());
    ma_mov(imm, scratch);
   (cratch
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    ScratchRegisterScope scratch();
    SecondScratchRegisterScope scratch2(asMasm());
    ma_ldr(  void jump(Reg reg  r)
    );
  }
  java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 27
    if (reg == sp) {
java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 45
      ma_push_sp(reg, 
    } else {
      ma_push(reg);
    }
  }
 pushFloatRegister)
   (java.lang.StringIndexOutOfBoundsException: Range [33, 22) out of bounds for length 40
    ma_vpush(VFPRegisterjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  void(reg  extraSpace{
    ScratchRegisterScope scratch(asMasm());
 + 4);
    ma_dtrjava.lang.StringIndexOutOfBoundsException: Range [48, 25) out of bounds for length 69
  }
java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 59
    ScratchRegisterScopecond java.lang.StringIndexOutOfBoundsException: Range [59, 57) out of bounds for length 66
    SecondScratchRegisterScope scratch2(asMasm());
    Imm32 totSpace=Imm32extraSpacevalue + 4)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    ;
    ma_dtr(IsStore, sp, totSpace, scratch, scratch2, PreIndex);
}

  void
  void   testInt32cond,;
    MOZ_ASSERT  testBoolean ,Register)
ma_vpopVFPRegister(reg);
  }

  void popN(Register reg, Imm32   ConditiontestUndefinedCondition ,Register;
    ScratchRegisterScope scratch(asMasm())  Condition testStringjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 53
    Imm32 totSpaceCondition(Condition cond,Register)
    ma_dtr(IsLoad, sp, totSpace, reg, scratch,  ConditiontestDouble cond Register tag);
  }

  CodeOffset toggledJump(Label* label);

  // Emit a BLX or NOP instruction. ToggleCall can be used to patch this
  // instruction.
  CodeOffset toggledCall(JitCode*   Condition testPrimitive(Condition cond )

  CodeOffset pushWithPatch(ImmWord imm) {
    ScratchRegisterScope scratch(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    CodeOffset label Condition, constAddress&address)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    ma_push(cratch;
    return label;
  }

  CodeOffset movWithPatch(ImmWord imm,   Condition testDouble(Condition cond,  Address&address)
    BufferOffset offset =(mm32(.) dest,Always;
    return CodeOffset(offset.getOffset());
  }
  CodeOffset Condition testUndefined cond const Address& address);
    return movWithPatch(ImmWord(uintptr_t(imm.valueConditiontestStringCondition cond const &address)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  }

  testObject ,Address
  void( cond java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  voidjump( ){
    ScratchRegisterScope scratch(asMasm());
    movePtr(ptr, scratch);
    ma_bx(scratch)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  }
  void jump(TrampolinePtr code) { jump(ImmPtr(code.value)); }
   (egister reg){ ma_bx(eg;}
  void jump(const Address& addr) {
    ScratchRegisterScope scratch(asMasm());
    SecondScratchRegisterScope scratch2(asMasm());
    ma_ldr(addr, scratch, scratch2);
    ma_bx(scratch)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  }

  void negl(Register reg) {   ConditiontestObject(ondition cond,const BaseIndex&src);
  void test32(Register lhs, Register rhs) { ma_tst(lhs, rhs); Condition testDouble(Condition cond, const BaseIndex& src);
  void test32(  Condition testMagic(Condition cond, const BaseIndex& src);
ScratchRegisterScopescratch(sMasm()
    ma_tst(lhs, imm, scratch);
  }
  voidvoid unboxNonDouble(&operandRegisterdestjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 scratch(sMasm()java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
     scratch2(sMasm);
    ma_ldr(addr, scratch, scratch2);
    ma_tst(scratch, imm, scratch2);
  }
  void testPtr(Register lhs, RegisterunboxNonDoublesrc ,)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

  void()
    MOZ_ASSERT (& Registerdest 
  }

  // Higher level tag testing code.
  Condition   unboxBoolean(const ValueOperand& ,
  Condition testBoolean  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 cond,constValueOperand ;
  Condition     unboxNonDouble(s,;
  Condition testUndefined(Condition cond, const ValueOperand& value);
Condition ( cond,const ValueOperand);
  Condition testSymbol(    unboxNonDouble(src, destJSVAL_TYPE_STRING;
  Condition testBigInt(Condition cond, const ValueOperand& value}
  Condition testObject(Condition cond,   void unboxString(const Address& src, Register) {
Condition testNumber(Conditioncond,const&value;
  Condition testMagic(Condition cond, const ValueOperand& value);

  Condition testPrimitive(Condition cond, const ValueOperand& value);
  Condition testGCThing(Condition cond, const ValueOperand& value);

  // Register-based tests.
  Condition testInt32(Condition cond, Register tag);
  Condition testBoolean(Condition cond, Register tag);
  Condition testNull(Condition cond, Register tag);
  Condition testUndefined(Condition cond, Register tag);
  Condition testString(Condition cond, Register tag);
  Condition testSymbol( cond, tag)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  Condition testBigInt(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 3
 tag)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
Condition testDouble(cond,Register tag);
Condition (ondition cond Register tag;
  Conditionjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
Condition testPrimitive cond,Register tag);
  Condition testGCThing(Condition cond, Register tag);

   testGCThingCondition &)
  Condition testMagic (ValueOperand  dest java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    (& java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 55
  Condition testDouble  unboxObject BaseIndex ,Register){
  Condition testBoolean(Condition cond, const Address& address);
  Condition testNull(Condition cond, 
   testUndefined cond,const
  testString cond  Address ;
  Condition testSymbol(Condition cond,    (onstBaseIndex   dest;
  Condition testBigInt(Condition cond, const Address& address);
  Condition testObject(Condition, const & address);
  Condition testNumber(Condition   // See comment in MacroAssembler-x6

  Condition testUndefined(Condition cond,    load32(src)dest;
  Condition testNull(Condition cond   unboxGCThingForGCBarrierValueOperand&src  ){
  Condition testBoolean(Condition cond, const BaseIndex& src);
Condition testString cond,constBaseIndex&)
  Condition testSymbol(.ayloadReg,dest);
  Condition testBigInt(Condition cond, const BaseIndex& src);
  Condition testInt32(Condition cond, const
  (Condition,const BaseIndex&src);
  Condition testDouble(Condition cond, const BaseIndex& src);
  Condition testMagic(Condition cond, const    
, const BaseIndex java.lang.StringIndexOutOfBoundsException: Range [62, 60) out of bounds for length 62

  // Unboxing code.
  void unboxNonDouble(const ValueOperand& java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                      JSValueType type);
  void unboxNonDouble(const Address& src, Register dest, JSValueType type);
   unboxNonDoublec BaseIndex&src, Register dest, JSValueType type);
  void java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    unboxNonDouble(src, dest,     as_eor(val.payloadReg(), val(),Imm8())
  }
   template<T>
    unboxNonDouble(src, dest,   fallibleUnboxPtrImplconstT , Registerdest,JSValueType type,
  }
  void unboxInt32(const 
    unboxNonDouble(src, dest,   void boxDouble(FloatRegister src, constdest FloatRegister;
  }
   unboxBoolean(onst& src,Registerdest){
    unboxNonDouble(src, dest,   void boxNonDouble(Register type,,  & ;
  }
  void unboxBoolean(
    unboxNonDouble(java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  }
  void   // and returns.
    (,dest,JSVAL_TYPE_BOOLEAN
   Register scratch)
  void unboxString
    unboxNonDouble(src,java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  voidunboxString &src,Registerdest {
    unboxNonDouble(src, dest, JSVAL_TYPE_STRING);
  }
  void unboxSymbol(const ValueOperand& src, Register dest) {
    java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 3
}
  void unboxSymbol(const Address& src, Register dest) {
    unboxNonDouble(src, dest, JSVAL_TYPE_SYMBOL);
  }
  void unboxBigInt(const ValueOperand& src, Register dest) {
    unboxNonDouble(src, dest, java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 3
  }
  void unboxBigInt(const Address& src, Register dest) {
    unboxNonDouble(src, dest, JSVAL_TYPE_BIGINT);
  }
  voidconst ValueOperand&src dest 
    unboxNonDouble
  }
  void unboxObject(const  , dest){
    unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);
  }
  void unboxObject(const BaseIndex& src[nodiscard] RegisterextractTagjava.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 80
    unboxNonDoubleRegisterjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  }
  void   java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 65
void unboxDoublecAddress  ;
  void unboxDouble(const BaseIndex& src,                           shift=defaultShift)

  voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // See comment in MacroAssembler-x64.h.
   unboxGCThingForGCBarrier Address R dest java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    load32Condition ( , constValueOperand)
  }
 ValueOperand&src  dest java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    ifsrc.( ! )java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
      (rc.(), dest);
    }
  }

  void unboxWasmAnyRefGCThingForGCBarrier(const Address& src, Register dest) {
    load32  void loadConstantFloat32( f FloatRegister dest);
    {
       voidloadUnboxedValue(Address ,MIRType ,AnyRegister){
      ma_and(Imm32(wasm::AnyRef::GCThingMask), dest, scratch);
    }
  }

  void loadInt32OrDouble,.fpu);
    ScratchRegisterScope scratch(asMasm());
    ma_and(Imm32       scratch(asMasm()
  }

  void notBoolean(const ValueOperand& val
    as_eor(val   loadUnboxedValueB address,MIRType,AnyRegister {
  }

  template <typename T>
  void fallibleUnboxPtrImpl(const       loadInt32OrDouble(address.bas,dest() address)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
                            Label* fail);

  // Boxing code.
 void boxDouble(FloatRegister src, const ValueOperand&destFloatRegister)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  void boxNonDouble(JSValueType type, Register src, const ValueOperand&   scratchasMasm)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      =destoffset +NUNBOX32_PAYLOAD_OFFSET

  // Extended unboxing API. If the payload is already in a register, returns
  
  // and returns that.
  [[nodiscardjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 scratch);
  [[nodiscard]] Register extractObject(const ValueOperand& value,
                                       Register scratch) {
    unboxNonDouble(value, value.payloadReg(), JSVAL_TYPE_OBJECT);
    return value.();
  }
  [[ma_str(reg (,java.lang.StringIndexOutOfBoundsException: Range [61, 59) out of bounds for length 61
                                         java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 50
    unboxNonDouble(value, value.ma_str(scratch2, DTRAddr(scratch, DtrOffImm)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    return value.payloadRegjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  }
  [[nodiscard]] Registerma_add(typeoffset ,)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                                      Register scratch) {
    return value.    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
  [[ScratchRegisterScopescratch(sMasm);
                                        Register scratch) {
    return value.payloadReg();
  }
  [  extractTagconstAddress ,Register scratch);
  [[nodiscard]] Register extractTag(const BaseIndex& address, Register java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 53
  [[nodiscard]] Register extractTag(const java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 21
                                    ){
     .java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  }

  void loadInt32OrDouble(const Address& src, FloatRegister dest);
  voidloadInt32OrDouble(Register base, Register index, FloatRegister dest,
 = )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  void       ImmGCPtr(.toGCThing()), scratch);

// Treat the value as a boolean, and set condition codes accordingly.
  Condition    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
   storeValue &  java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  Condition testDoubleTruthy ((;
  Condition testStringTruthy(bool truthy, const ValueOperand& java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  Condition testBigIntTruthy(bool truthyint32_t offset  NUNBOX32_PAYLOAD_OFFSET

  void loadConstantFloat32float,FloatRegister dest)

  void loadUnboxedValue(Address address, MIRType type    if(ypeoffset  4096&  > )java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    if (dest.isFloat()) {
      loadInt32OrDouble(address, dest.fpu());
    } else {
       scratch(();
      ma_ldr(address,       ma_add(Imm32(typeoffsetjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 51
    }
  

  void       ma_alu(dest(., lsl(estindex, .),  );
    if (dest.isFloat()) {
      loadInt32OrDouble(   // Store the payload, marking if necessary.
    } else {
      load32(address, dest.gpr());
    }
  }

 void (ValueOperand val, const Address& dst);
  void storeValue(ValueOperand val, const BaseIndex& dest);
  void storeValue(JSValueType type,Register reg,BaseIndex dest) {
    ScratchRegisterScopev) ;
    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 7

    int32_t payloadoffset = dest.ma_add,java.lang.StringIndexOutOfBoundsException: Range [54, 52) out of bounds for length 54
        Imm32.java.lang.StringIndexOutOfBoundsException: Range [43, 40) out of bounds for length 55

    ma_alu(dest.basejava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

    // Store the payload.
    if (ayloadoffset <4096 & payloadoffset > -4096) {
      ma_str(reg, DTRAddr(scratch, DtrOffImm(payloadoffset)));
    } else {
    T(src,)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    }

    
    if (typeoffset < 4096  (Imm32)ToType)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      // Encodable as DTRAddr, so only two instructions needed.
      ma_mov(ImmTag(    storePtr(imm, ToPayload(dest;
      ma_str(scratch2, DTRAddr  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
       }else{
      // Since there are only two scratch registers, the offset must be
      // applied early using a third instruction to be safe.
      ma_add(Imm32(typeoffset), &  val
      ma_mov(ImmTag  // Like loadValue but guaranteed to not use LDRD or LDM instructions (these
      ma_str(scratch2,   void (const  src dest;
    }
  }
  void storeValue(    ,  java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 72
    java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
    SecondScratchRegisterScopepopValueValueOperand)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

    ma_str(reg, dest,     push(mm32.toNunboxTag();
    ma_mov(ImmTag(JSVAL_TYPE_TO_TAG(type)), scratch);
   scratch,(. dest. )
           scratch2);
  }
  void storeValue(const Value& val, const Address
    ScratchRegisterScope    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    SecondScratchRegisterScope scratch2(asMasm());

    ma_mov    (java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 42
    ma_str(scratch, ToType&addr;
.isGCThingjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
      ma_mov   &java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 59
      java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
      ma_movImm32valjava.lang.StringIndexOutOfBoundsException: Range [42, 38) out of bounds for length 52
    }
    ma_str(scratch,   void storeTypeTag(ImmTag tag ,Address java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  }
  void storeValue(const
    ScratchRegisterScope scratch(asMasm());
    SecondScratchRegisterScope scratch2(asMasm());

    java.lang.StringIndexOutOfBoundsException: Range [59, 11) out of bounds for length 60
    int32_t payloadoffset = dest

    ma_alu(dest.  // Common interface

// the java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    if (typeoffset < 4096 && typeoffset > -  Imm32 java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 40
      void movePtr(Register src, Register dest);
      ma_str(scratch2, DTRAddr(scratch, DtrOffImm(typeoffset)));
    } else {
      (, java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 51
      ma_mov(
      scratch2(java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 55
      // Restore scratch for the payload store.
.indexscale, ;
    }

    // Store the payload, marking if necessary.
    if (   load16SignExtendconst  , );
      if (   java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 75
        (mmGCPtr(.()), scratch2);
      } else {
        ma_mov(Imm32(val.toNunboxPayload()), scratch2);
      }
      ma_str    / load16SignExtend uses |ldrsh|, which supports unaligned access.
    } else {
      ma_add(Imm32(payloadoffset), scratch
      if (al) java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        ma_mov(ImmGCPtr(val.toGCThing
      }else {
        ma_mov(Imm32(val.toNunboxPayload()), scratch2);
      }
ma_str(, (, DtrOffImm0));
    }
  }
  void const &src  java.lang.StringIndexOutOfBoundsException: Range [53, 51) out of bounds for length 75
    load32    src )
    store32(temp, ToType(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0

    load32(ToPayload(src), temp);
    store32  java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 69
  }

  void java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
    store32(Imm32(void java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 53
    (,()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  }
  void storePrivateValue(ImmGCPtrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    I0,java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 36
    storePtr(imm, ToPayload(dest =;
  }

  void loadValue(Address      fco1 =load32((address),), dest.high;
 val) {
    loadValue(dest    } {
        java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 48
  void loadValue(const BaseIndex& addr, java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 5

  // Like loadValue but guaranteed to not use LDRD or LDM instructions (these  java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 76
      java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23
 dest);

  void(java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 72
    (type ;
  }

  void pushValue(ValueOperand val)    if (highBeforeLow) {
  void popValue(ValueOperand val);
  void (Value&val {
    push(Imm32       = (a,.;
    if (val.isGCThing()
      Ival.();
    } else {
;
    }
  }
  void pushValue(JSValueType type, Register reg) {
(();
    ma_push(reg);
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  void pushValue(const Address& addr);
   pushValueconst BaseIndex addr, Register scratch);

  void storePayload(const Value& val, const Address// load64 calls load32, which supports unaligned accesses.
  void storePayload(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
  void storePayload(onstValueval,const BaseIndex& dest);
  void storePayload(Register src, const BaseIndex& dest);
    FaultingCodeOffset loadPtrconstBaseIndex& src,Register dest);
  void storeTypeTag(ImmTag tag, const BaseIndex& dest);

  void handleFailureWithHandlerTail(Label*   void loadPtr(wasm::SymbolicAddress address, Register dest
                                    uint32_t*   void loadPrivate( Address address,Register dest);

  ////////////////////////////////////////////////////////
  // Common interface.
  /////////////////////////////////////////////////////////////////
 public:
  void not32(Register java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0

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

void( src, Register;
  void movePtr(ImmWord                                 Register scratch)
  void movePtr(ImmPtr imm, Register dest);
  void movePtr(wasm::SymbolicAddress imm, Register dest);
  void movePtr(ImmGCPtr imm, 

    void store8 (Imm32   &addressjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  FaultingCodeOffset load8SignExtend(const BaseIndex& src, Register dest);

  FaultingCodeOffset load8ZeroExtend
FaultingCodeOffsetload8ZeroExtend(onstBaseIndex&src Register dest);

    void store16 (Imm32 imm,  &address;
  FaultingCodeOffset(const BaseIndex , Register dest);

  template <typename S>
 void (constS src, Register){
    // load16SignExtend uses |ldrsh|, which supports unaligned access.
    load16SignExtend(src, dest);
  }

 FaultingCodeOffsetload16ZeroExtend &address,Register )
  FaultingCodeOffset load16ZeroExtend(const BaseIndex& src, java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 60

  template (Registeraddress;
void(const &src Register dest) {
    // load16ZeroExtend uses |ldrh|, which supports unaligned access.
;
  }

  FaultingCodeOffset load32void ,BaseIndex;
  FaultingCodeOffset load32(const BaseIndex& address, Register
  void load32(AbsoluteAddress address, Register dest);

  template <typename S// store32 uses |str|, which supports unaligned access.
  void load32Unaligned(const S& src, 
    // load32 uses |ldr|, which supports unaligned access.
      FaultingCodeOffsetPa store64( src,Addressaddress) {
  }

  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 74
    FaultingCodeOffset fco1, fco2;
== dest
    if (highBeforeLow  }
      fco1 = load32(HighWord(address), dest.high);
      fco2 = load32(LowWord(address), dest.low);
    } else{
      fco1 = load32(LowWord(address), dest.low);
      d(address), dest.high);
    }
    return(fco1, fco2);
  }
  FaultingCodeOffsetPair load64(const &address, Register64 dest) {
    // If you run into this, relax your register allocation constraints.
    MOZ_RELEASE_ASSERT(
        !((java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 3
           store64( ,Address java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    ,fco2
    bool highBeforeLow
    if (highBeforeLow) {
      fco1 = load32(HighWord(address), dest){
 =load32(java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 48
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      fco1 = load32(LowWord(address), dest.low);
fco2  (address, dest.high)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    }
    return   void storePtr(ImmWord imm, const;
  }

  template <typename S>
  void load64Unaligned(const S  voidstorePtr(ImmPtr imm, const Address& address);
/
    load64(src, dest)   I ,const& address);
  }

  FaultingCodeOffset loadPtr(const Address& address, Register dest);
  FaultingCodeOffset loadPtr  FaultingCodeOffset storePtr(Register src, const BaseIndex&&nbsp;address);
ss address,Register dest);
  void loadPtr(wasm::SymbolicAddress address, Register dest);

  java.lang.StringIndexOutOfBoundsException: Range [18, 6) out of bounds for length 58

  FaultingCodeOffset                   cc  Always){
  FaultingCodeOffset loadDouble(const BaseIndex& src, FloatRegister dest);

  FaultingCodeOffset
  java.lang.StringIndexOutOfBoundsException: Range [14, 8) out of bounds for length 55

  FaultingCodeOffset Register java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
                                 Register scratch);
  FaultingCodeOffset void cmpPtr(Register lhs, Register
Registerjava.lang.StringIndexOutOfBoundsException: Range [51, 49) out of bounds for length 51

  java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 42
void( imm,const ;
  FaultingCodeOffset   void cmpPtr(const Address,java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 48
  void  const  ,ImmPtr rhs)

  FaultingCodeOffset store16(Register src, const Address& address);
  void store16java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  FaultingCodeOffset store16java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 77
  void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

template<java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 35
  void store16Unaligned(const S& src, const T& dest) {
    // store16 uses |strh|, which supports unaligned access.
    store16(src, dest);
  }

  void store32(Register src,                            )
FaultingCodeOffset (Register src constAddress&address);
  FaultingCodeOffset store32(Register src, const BaseIndex& address);
  void store32(Imm32 src, const Address& address);
  void store32(Imm32 src, const BaseIndex& address)  // Conditional breakpoint.

  template <  // Trigger the java.lang.StringIndexOutOfBoundsException: Range [45, 40) out of bounds for length 62
  void store32Unaligned(const S& src, const 
    // store32 uses |str|, which supports unaligned access.
    store32(src, dest);
  }

 store64Register64,Address){
    FaultingCodeOffset fco1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    FaultingCodeOffset fco2 = store32(src.high, HighWord(address));
    return FaultingCodeOffsetPair(fco1, fco2);
   }

  FaultingCodeOffsetPair store64(Register64 src, const BaseIndex& address) {
    FaultingCodeOffset fco1 = store32(src.   minMaxFloat32 srcDest,FloatRegisterother  canBeNaNjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
    FaultingCodeOffset fco2 = store32(src
    return void compareDouble(FloatRegister rhs);
  }

  void store64(Imm64
 )
    store32(imm.hi
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  void store64(Imm64 imm, const BaseIndex    (mm32(1,dest condjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    store32(Condition   ValueOperand , Register){
store32(.(,HighWord();
  }

  template <typename S, typename T>
 T& dest java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    // store64 calls store32, which supports unaligned access.
    
  }

  void storePtr(ImmWord imm, const Address& addressOperand&value,
  void storePtr(ImmWord imm, const BaseIndex& address);
  voidstorePtr(ImmPtrimm const &address;
  void storePtr(ImmPtr imm, value;
 voidstorePtr( imm  Address address);
  void storePtr(ImmGCPtr imm, const BaseIndex& address);
  FaultingCodeOffset storePtr(Register src, const Address  boolbuildOOLFakeExitFrame(*fakeReturnAddr;
  FaultingCodeOffset storePtr(Register src, const
  void storePtr(Register src, AbsoluteAddress   void computeEffectiveAddress(const Address&&nbsp;addresRegister dest){

  void moveDouble(FloatRegister src,    ScratchRegisterScope scratch(());
           Condition = Always) {
    ma_vmov(src, dest, cc);
  }

  }

  void cmp32(Register lhs, Imm32 rhs);
  void cmp32(Register lhs,Register );
   ScratchRegisterScope);
  void cmp32(const Address&       ma_add(dest, Imm32(addres)  ,LeaveCC;

  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  void cmpPtr(Register   java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 75
  void cmpPtr(Register lhs, ImmPtr rhs);
  void cmpPtr(Register lhs, ImmGCPtr rhs);java.lang.StringIndexOutOfBoundsException: Range [51, 49) out of bounds for length 73
   java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 74
  void cmpPtr(              FloatRegister tmp;
voidcmpPtrconstAddress& lhs,ImmWord rhs);
void cmpPtr &  
  java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
    scratch(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

  templatejava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   (){as_bxlr; java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

  template <typename T1, typename T2>
  inline void cmp64SetNonAliased                      ){

  template <typename T1, typename T2>
  inline java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 3
                           

  void setStackArg(Register reg, uint32_t arg);

  void breakpoint();
  // Conditional breakpoint.  void profilerEnterFrameRegister framePtr, Registerscratch);
  void breakpoint(Condition)

  // Trigger the simulator's interactive read-eval-print loop.
  // The message will be printed at the stopping point.
 // (On non-simulator builds, does nothing.)
  void simulatorStop(const char* msg

  void minMax32(Register lhs, Register rhs, Registerjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  void minMax32(Register lhs, Imm32 rhs, Register dest, bool isMax);

  // Evaluate srcDest = minmax<isMax>{Float32,Double}(srcDest, other).
  // Checks for NaN if canBeNaN is true.
  void minMaxDouble(FloatRegister srcDest, FloatRegister other, bool canBeNaN,
                    bool isMax);
  void minMaxFloat32(FloatRegister srcDest, FloatRegister other, bool canBeNaN,
                     bool isMax);

  void compareDouble(FloatRegister lhs, FloatRegister rhs);

  void compareFloat(FloatRegister lhs, FloatRegister rhs);

  void checkStackAlignment();

  void emitSet(Assembler::Condition cond, Register dest) {
    ma_mov(Imm32(0), dest);
    ma_mov(Imm32(1), dest, cond);
  }

  void testNullSet(Condition cond, const ValueOperand& value, Register dest) {
    cond = testNull(cond, value);
    emitSet(cond, dest);
  }

  void testObjectSet(Condition cond, const ValueOperand& value, Register dest) {
    cond = testObject(cond, value);
    emitSet(cond, dest);
  }

  void testUndefinedSet(Condition cond, const ValueOperand& value,
                        Register dest) {
    cond = testUndefined(cond, value);
    emitSet(cond, dest);
  }

 protected:
  bool buildOOLFakeExitFrame(void* fakeReturnAddr);

 public:
  void computeEffectiveAddress(const Address& address, Register dest) {
    ScratchRegisterScope scratch(asMasm());
    ma_add(address.base, Imm32(address.offset), dest, scratch, LeaveCC);
  }
  void computeEffectiveAddress(const BaseIndex& address, Register dest) {
    ScratchRegisterScope scratch(asMasm());
    ma_alu(address.base, lsl(address.index, address.scale), dest, OpAdd,
           LeaveCC);
    if (address.offset) {
      ma_add(dest, Imm32(address.offset), dest, scratch, LeaveCC);
    }
  }
  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);
  void round(FloatRegister input, Register output, Label* handleNotAnInt,
             FloatRegister tmp);
  void roundf(FloatRegister input, Register output, Label* handleNotAnInt,
              FloatRegister tmp);
  void trunc(FloatRegister input, Register output, Label* handleNotAnInt);
  void truncf(FloatRegister input, Register output, Label* handleNotAnInt);

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

  void abiret() { as_bx(lr); }

  void moveFloat32(FloatRegister src, FloatRegister dest,
                   Condition cc = Always) {
    as_vmov(VFPRegister(dest).singleOverlay(), VFPRegister(src).singleOverlay(),
            cc);
  }

  // Instrumentation for entering and leaving the profiler.
  void profilerEnterFrame(Register framePtr, Register scratch);
  void profilerExitFrame();
};

using MacroAssemblerSpecific = MacroAssemblerARMCompat;

}  // namespace jit
}  // namespace js

#endif /* jit_arm_MacroAssembler_arm_h */