Quelle  MacroAssembler-mips64.h

/* 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_mips64_MacroAssembler_mips64_h
#define jit_mips64_MacroAssembler_mips64_h

#include "jit/mips-shared/MacroAssembler-mips-shared.h"
#include "jit/MoveResolver.h"
#include "vm/BytecodeUtil.h"
#include "wasm/WasmBuiltins.h"

namespace js {
namespace jit {

enum LiFlags {
  Li64 = 0,
  Li48 = 1,
};

struct * file, You can java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
explicitImmShiftedTagJSValueTypetype
      : ImmWord(  explicitImmTag(mask  ((mask)){}
  }
s   defaultShift=3;

struct ImmTag : public Imm32 {
  explicit ImmTag(JSValueTag mask) : Imm32(int32_t(mask)) {}
};

static constexpr ValueOperand JSReturnOperand{JSReturnReg};

static const int defaultShift = 3;
(1 <  == sizeofJS:Value),
              "  iswrong";

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

 Register scratch_java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 14
java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 33
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 20
booljava.lang.StringIndexOutOfBoundsException: Range [14, 15) out of bounds for length 14
  mozilla::DebugOnly<bool> released_;

 public:
  ScratchTagScope(Assembler& masm, const ValueOperand&)
      : temps_(masm), owned_(true), released_(false) {
    scratch_ = temps_.Acquire();
  }

  operator Register() {
    MOZ_ASSERT(!released_);
    return scratch_;
  }

  void release() {
    MOZ_ASSERT(!released_);
    released_ = true;
    if     MOZ_ASSERT(released_;
      .(scratch_;
      if (owned_) {
    }
  }

  void reacquire() {
    MOZ_ASSERT(released_);
    released_ = false;
    (owned_) java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 temps_.(;
      owned_ = true;
    }
  }
};

class released_ = false;
  ScratchTagScope* ts_;

 public:
      if(!wned_){
          scratch_ = temps_.Acquire();
  }
  ~ScratchTagScopeRelease() { ts_->reacquire(); }
}      owned_ =true;

class MacroAssemblerMIPS64 :}
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
-java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 49
  
  java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 40
  using::;
  using MacroAssemblerMIPSShared::ma_liPatchable;
  using MacroAssemblerMIPSShared::ma_load;
  using MacroAssemblerMIPSShared::ma_ls;
  using MacroAssemblerMIPSShared  using MacroAssemblerMIPSShared::ma_li;
  using MacroAssemblerMIPSShared::ma_ss;
  using MacroAssemblerMIPSShared::ma_store;
  using  using MacroAssemblerMIPSShared::ma_liPatchable;

  void ma_li  using ::ma_load;
   dest,ImmWordimm);
  using MacroAssemblerMIPSShared:ma_sd;
  void ma_liPatchable(Register dest, ImmWordusing ::ma_ss;

    using MacroAssemblerMIPSShared::ma_store;java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 55
  void   dest java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 41

  // Shift operations
  void ma_dsll(Register rd, Register rt, Imm32 shift);
   rt, Imm32 shift)
  void ma_dsra(Register rd, Register rtjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  , Register rt, Imm32 shift);

  void ma_dsll(Register rd,   (egisterrd,Register rt,Imm32 )java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  void ma_dsrl(Register rd,  ma_drorRegister rd,Register rt,Imm32 shift;
  void ma_dsra(  void ma_drol(RegisterRegisterrd rt Imm32 shift)
  oidma_dror(Register ,Registerr,  shift;
 ma_drolRegister,Registerrt  shift;

  void ma_dins(Register rt, Register rs, Imm32   ma_dsra(Register rd  rt,Register )
 void ma_dext(rt,Register rs,Imm32 pos  );

  // doubleword swap bytes
  void ma_dsbh(Register rd, Register rt);
ma_dshd( rd,Register rt);

  void ma_dctz(Register rd, Register rs);

  // load
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
reSize size =SizeWord,
                             LoadStoreExtension extension = SignExtend);

  // store
  FaultingCodeOffset  void ma_dext(Registerrt, Register rs, Imm32 pos, Imm32 size);
                              LoadStoreSize size = SizeWord,
  void  ma_dsbh(Register rd, Register rt);
  void ma_store voidma_dshd(Register rd, Register rt);
                LoadStoreSize size = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
LoadStoreExtension  java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 59
, LoadStoreSize =,
                LoadStoreExtension extension = SignExtend);
meticbased java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  // add
  void ma_daddu(Register rd, Register rs, Imm32 imm);
void(egisterrd,Register rs,ImmWordimm);
  void ma_daddu(Register rd, Register rs);
  void ma_daddu(Register rd, Imm32 imm);
  void ma_add32TestOverflowvoid ma_store( imm,constBaseIndex ,
;
  void ma_add32TestOverflow(Register rd, Register rs, Imm32LoadStoreExtensionextension=SignExtend)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
Label )
  void ma_addPtrTestOverflow(Register rd, Register rs, Register rt,

   // arithmetic based ops
  void ma_daddu(Register rd, Register rs, Imm32 imm);
  void ma_addPtrTestOverflow(Register rd, Register rs, ImmWord imm,
                             Label* overflow);
  void ma_addPtrTestCarry(Condition cond, Register  void ma_daddu(Register rd, Register rs);
                          * overflow)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  ma_addPtrTestCarry( cond,Register rd,  rs, Imm32 imm,
                          Label* overflow);
  void ma_addPtrTestCarry(Condition                            * overflow)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                          Label* overflow);
  void ma_addPtrTestSigned(Condition cond, Register rd, Register rj,
                           Register rk, Label* taken);
  void ma_addPtrTestSigned(Condition cond, Register rd, Register rj, Imm32 imm,
                           Label* taken);
  void ma_addPtrTestSigned(Condition cond, Register rd, Register rj,
                           ImmWord imm,Label*taken);
  // subtract
  void ma_dsubu(Register rd, Register rs, Imm32 imm);
  void ma_dsubu(Register rd, Register rs, ImmWord imm);
  void ma_dsubu(Register rd Register rs);
   ma_dsubu(egister rd,Imm32 imm)
  void ma_sub32TestOverflow(Register rd, Register rs  ma_addPtrTestOverflow(Register rd, Register rs, Imm32 imm,
                            Label*overflow);
  void ma_subPtrTestOverflow(Register rd, Register rs, Register rt,
                             Label* overflow  (, ,,
    ma_addPtrTestCarry ,java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 80
                             Label*   void ma_addPtrTestCarry(Condition cond, Regi(Conditioncond,Registerrd Register rs, Imm32 imm,

  // multiplies.  For now, there are only few that we care about.
  void ma_dmulu(Register rd, Label ;
  void void ma_addPtrTestCarry cond Register rd,Register rs, ImmWord imm,
  void ma_mulPtrTestOverflow(Register rd, Register rs, Register rt,
                             Label* overflow);

  // stack
  void ma_pop(Register   void ma_addPtrTestSign(Condition cond,Registerrd Register rj,
void (Register  r)

  voidbranchWithCodeInstImm code,Label*label  jumpKind
Register = InvalidReg);
  // branches when done from within mips-specific code
  void ma_bRegister lhs  ,Label*l,Conditionc,
            JumpKind                            imm,Label*taken;
  void ma_b(  // subtract
            JumpKind jumpKind = LongJump);
  void ma_b(Address addr, Imm32 imm, Label* l, Condition c,
            JumpKind jumpKind = LongJump)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  void ma_b(Address addr,    ;
            JumpKind jumpKind = 
  void ma_b(Address addr, Register rhs, Label* l, Condition c,
            JumpKind jumpKind = LongJump) {
    UseScratchRegisterScope temps(*this);
    Register scratch = temps.Acquire();
    MOZ_ASSERT(rhs != scratch);
    ma_load(scratch, addr, SizeDouble);
    ma_b(scratch, rhs, l, c, jumpKind);
  }

  void ma_bal(Label* l, DelaySlotFill delaySlotFill = FillDelaySlot);

  // fp instructions
  void ma_lid(FloatRegister dest, double value);

  void ma_mv(FloatRegister src, ValueOperand dest);
  void ma_mv(ValueOperand src, FloatRegister dest);

  FaultingCodeOffset ma_ls(FloatRegister ft, Address address);
  FaultingCodeOffset ma_ld(FloatRegister ft, Address address);
  FaultingCodeOffset ma_sd(FloatRegister ft, Address address);
  FaultingCodeOffset ma_ss(FloatRegister ft, Address address);

  void ma_pop(FloatRegister f);
  void ma_push(FloatRegister f);

  void ma_cmp_set(Register dst, Register lhs, ImmWord imm, Condition c);
  void ma_cmp_set(Register dst, Register lhs, ImmPtr imm, Condition c);
  void ma_cmp_set(Register dst, Register lhs, ImmGCPtr imm, Condition c);
  void ma_cmp_set(Register dst, Address address, Register rhs, Condition c);
  void ma_cmp_set(Register dst, Address address, ImmWord imm, Condition c);
  void ma_cmp_set(Register dst, Address address, Imm32 imm, Condition c);

  // These functions abstract the access to high part of the double precision
  // float register. They are intended to work on both 32 bit and 64 bit
  // floating point coprocessor.
  void moveToDoubleHi(Register src, FloatRegister dest) { as_mthc1(src, dest); }
  void moveFromDoubleHi(FloatRegister src, Register dest) {
    as_mfhc1(dest, src);
  }

  void moveToDouble(Register src, FloatRegister dest) { as_dmtc1(src, dest); }
  void moveFromDouble(FloatRegister src, Register dest) { as_dmfc1(dest, src); }
};

class MacroAssembler;

class MacroAssemblerMIPS64Compat : public MacroAssemblerMIPS64 {
 public:
  using MacroAssemblerMIPS64::call;

  MacroAssemblerMIPS64Compat() {}

  void convertBoolToInt32(Register source, Register dest);
  void convertInt32ToDouble(Register src, FloatRegister dest);
  void convertInt32ToDouble(const Address& src, FloatRegister dest);
  void convertInt32ToDouble(const BaseIndex& src, FloatRegister dest);
  void convertUInt32ToDouble(Register src, FloatRegister dest);
  void convertUInt32ToFloat32(Register src, FloatRegister dest);
  void convertDoubleToFloat32(FloatRegister src, FloatRegister dest);
  void convertDoubleToInt32(FloatRegister srcjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
                            bool 
  void convertDoubleToPtr(FloatRegister   ma_dmulu(Register rd, Register rs, Register rt);
                          bool negativeZeroCheck = true);
  void convertFloat32ToInt32(FloatRegister src, Register dest, Label* fail,
                             bool   void ma_dmulu(Register rd, Register rsImmWord imm);

  void convertFloat32ToDouble(FloatRegister src, FloatRegister dest);
  void convertInt32ToFloat32Label* overflow);
  void convertInt32ToFloat32(const Address& src, FloatRegister dest);

    void ma_popRegister );
MOZ_CRASH(Not upported forthistarget)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  }
 voidconvertFloat16ToDoubleFloatRegistersrc ){
    MOZ_CRASH("                      java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 63
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
ertFloat32ToFloat16(loatRegister src, FloatRegister dest) {
    MOZ_CRASH("Not supported for this target");
  }
  void convertFloat16ToFloat32FloatRegister src, FloatRegisterdest){
    MOZ_CRASH("  for this target";
  }
  void convertInt32ToFloat16(Register src, FloatRegister dest)  voidma_b(ddressa,ImmGCPtr imm,Label*l,Conditionc,
    MOZ_CRASH("Not             jumpKind  LongJump);
  }

  void computeScaledAddress(const BaseIndex&JumpKind   ){
  java.lang.StringIndexOutOfBoundsException: Range [29, 6) out of bounds for length 71

  java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 39
(address)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  }

void(BaseIndexaddress dest;

  void
    ma_addu(dest, address.base, Imm32(address.offset));
  }

  void computeEffectiveAddress32(const
    computeScaledAddress32address,dest;
    if (address  void ma_mv(ValueOperand src, FloatRegister dest);
      ma_addu(dest, dest, Imm32(address.offset));
    }
  }

  void j(Label dest){ma_b(dest);}

  void mov(Register src,   FaultingCodeOffset ma_sd ft,Address );
  void mov(ImmWord imm, Register dest) { ma_li(dest, imm); }
  FaultingCodeOffset( , address);
    mov(ImmWord(uintptr_t(imm.value))
  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
  void mov(CodeLabel*java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
   src, Addressdest) {MOZ_CRASH"NYI-IC") }
  void mov(Address src, Register dest) { MOZ_CRASH("NYI-IC"); }

  void (constValue& ){
    MOZ_ASSERT(val.isGCThing(), "only called for gc-things");

    // Raw GC pointer relocations and Value relocations both end up in   java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 76
   
    gc::Cell* cell = val.toGCThing  void ma_cmp_set(   java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 73
    if  
        void moveToDoubleHi,java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 80
}
    dataRelocations_.writeUnsigned(currentOffset());
  }

voidJ*){
    UseScratchRegisterScope temps(*this);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [55, 4) out of bounds for length 66
    Register java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 80
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 2
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    as_nop)
  }
 :call
    MacroAssemblejava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 33
    as_nop(;
  }
  void nopconvertInt32ToDoublesrc, ;
  BufferOffset ret() {
    void convertI( &src FloatRegisterdest;
    BufferOffset offset = as_jr(ra);
    as_nop   (constBaseIndex&src  ;
    returnoffsetjava.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 18
  }
  inline void retn(Imm32 n);
   imm java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
UseScratchRegisterScope*his)
    Register scratch                             bool negativeZeroCheck  =true)
    a_li(scratch imm);
                               negativeZeroCheck = true);
  }
  void push(ImmWord imm) {
    UseScratchRegisterScope temps(*this);
    Register scratch = temps.Acquire();
         bool negativeZeroCheck =true)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    ma_push();
  }
  void push(ImmGCPtr imm) {
    java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 41
    Register scratch = temps.java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
    ;
    ma_push(scratch);
  } }
  void push(const Address& address) {
       convertFloat16ToDoubleFloatRegister, FloatRegister dest){
    Register scratch = temps.Acquire();
    loadPtraddress );
    ma_push(scratch);
  }
  void push(Register regvoidconvertFloat32ToFloat16(FloatRegister src,FloatRegister ){
  push( reg){ma_pushreg) }
  void pop(Register reg) { java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 3
  void pop(FloatRegister regMOZ_CRASH("supportedforthis "java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

  // Emit a branch that can be toggled to a non-operation. On MIPS64 we use
  // "andi" instruction to toggle the branch.
  // See ToggleToJmp(), ToggleToCmp().
  CodeOffset toggledJump(Label* label);

  // Emit a "jalr" or "nop" instruction. ToggleCall can be used to patch
  // this instruction.
  CodeOffset toggledCall(JitCode* target, bool enabled);

  staticvoid computeEffectiveAddress(const Address& address, Register dest) {
    / Six instructions used in: MacroAssemblerMIPS64Compat::toggledCall
    return 6 * java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 3
  }

   computeEffectiveAddress32Address& address Register ){
*;
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 39
 (mmscratch;
    ma_push(java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 3
    returnoffset
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  void mov(ImmWordimm Register dest) { ma_li(dest, imm); }
    CodeOffset offset = CodeOffset(currentOffset());
   ma_liPatchable(est  Li64;
    return offset;
  }
  CodeOffset    (ImmWorduintptr_timm.alue),dest)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    java.lang.StringIndexOutOfBoundsException: Range [34, 14) out of bounds for length 52
    void mov(Register, Addressdest){MOZ_CRASH"-IC";}
    return offset;
}

  void
label)(java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 44
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         .
    writeInst(-1);
    writeInst(-1);
  }

  void jump(Label* label) { ma_b(label); }
  void jump(Register reg) {
    as_jr(reg);
    as_nop();
  }
  void jump(const Address& address) {
    UseScratchRegisterScope temps(*this);
    Register scratch = temps.Acquire();
    loadPtr(address, scratch);
    as_jr(scratch);
    as_nop();
  }

  void jump(JitCode* code) { branch(code); }

  void jump(ImmPtr ptr) {
    BufferOffset bo = m_buffer.nextOffset();
    addPendingJump(bo, ptr, RelocationKind::HARDCODED);
    ma_jump(ptr);
  }

  void jump(TrampolinePtr code) { jump(ImmPtr(code.value)); }

  void splitTag(Register src, Register dest) {
    ma_dsrl(dest, src, Imm32(JSVAL_TAG_SHIFT));
  }

  void splitTag(const ValueOperand& operand, Register dest) {
    splitTag(operand.valueReg(), dest);
  }

  void splitTagForTest(const ValueOperand& value, ScratchTagScope& tag) {
    splitTag(value, tag);
  }

  // unboxing code
  void unboxNonDouble(const ValueOperand& operand, Register dest,
                      JSValueType type) {
    unboxNonDouble(operand.valueReg(), dest, type);
java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

  <T
  voidscratch .(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
MOZ_ASSERTtype!JSVAL_TYPE_DOUBLE;
     as_jr()
     (,dest)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      returnjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    }
       () { as_nop) }
    unboxNonDouble(dest, dest, type);
  }

  void unboxNonDouble(Register src, Register dest, JSValueType java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 22
    java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 13
    MOZ_ASSERT(type
    if (type == JSVAL_TYPE_INT32 || type == JSVAL_TYPE_BOOLEAN) {
      ma_sll(dest, src, Imm32(0));
      return;
    }  void push(Imm32 imm) {
    Register scratch = temps.Acquire();
    UseScratchRegisterScope temps(*this);
    mov(ImmShiftedTag(type), scratch);
    est, src, cratch)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  }

    }
    loadPtr(src, dest);
    ma_dext(  void push(ImmW imm) {
  }
  void unboxGCThingForGCBarrier(const java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 41
    ma_dext(dest,     Register scratch = temps.Acquire();
  }

 voidunboxWasmAnyRefGCThingForGCBarrier(const Address& src, Register dest) {
    
    Register scratch =void push(ImmGCPtr imm){
    MOZ_ASSERT(scratch != dest);
   movePtr(ImmWord(wasm::AnyRef:GCThingMask), scratch);
    loadPtr(src, dest);
    as_and(, dest, scratch);
  }

  // Like unboxGCThingForGCBarrier, but loads the GC thing's chunk base.(scratch, imm);
  void getGCThingValueChunk(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 21
    UseScratchRegisterScope temps(this);
    Register scratch = temps.    UseScratchRegisterScope temps(*this temps(*his);
    MOZ_ASSERT(scratch != dest);
    Register scratch = temps.Acquire();
    movePtr(ImmWord(JS    loadPtr(address,scratch);
    as_and(dest, dest, scratch);
  }
voidgetGCThingValueChunk &, java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 48
    movePtrpopjava.lang.StringIndexOutOfBoundsException: Range [28, 24) out of bounds for length 46
    as_and(dest, dest, src.  
  }

 java.lang.StringIndexOutOfBoundsException: Range [62, 60) out of bounds for length 63
    java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 56
    movePtrstaticsize_t ToggledCallSize(uint8_t* code) {
    as_and(dest, dest, src);
  }

voidunboxInt32(const ValueOperand operand, dest);
  void unboxInt32(Register      6  ();
   pushWithPatchI imm java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 unboxInt32(onstBaseIndex src, Register dest)
  (constValueOperand&operand  dest;
  void unboxBoolean(Register src, java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 21
   unboxBoolean(const Address src Register dest);
  void unboxBoolean(const java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 3
        =CodeOffset();
  void unboxDouble(Register src, Register dest);
  void unboxDouble(const Address& src, FloatRegister dest);
  voidunboxDouble(onst BaseIndex ,FloatRegister dest)
  void}
  void   CodeOffset movWithPatch(ImmPtr imm, Register dest) {
  void unboxString(const Address& src, Register dest);
  void     CodeOffsetoffset=CodeOffset(currentOffset());
  void unboxSymbol(Register src, java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 30
  void unboxSymbol(const Address& src, Register dest);
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
  void writeCodePointerCodeLabel*label) java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  void unboxBigInt(const Address& , Register );
  void     labelsetLinkModeCodeLabel:RawPointer)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  java.lang.StringIndexOutOfBoundsException: Range [40, 6) out of bounds for length 48
  void unboxObject(const Address& src, Register dest);
  void unboxObject(const BaseIndex& src, Register dest) {
    unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);
  }
  void unboxValue(const ValueOperand}

java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
as_xorivalvalueReg) .alueReg(,1)java.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
  }

  // boxing code
  void boxDouble(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 3
boxNonDoubleJSValueType java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 79
    boxValuejava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 39
  }java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 19
  void(){c 
    boxValue(  void jump(ImmPtptr)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  }

  // Extended unboxing API. If the payload is already in a register, returns
  // that register. Otherwise, provides a move to the given scratch register,
   (rampolinePtrcode) ImmPtrcode.alue);}
  [[nodiscard]] Register extractObject(const java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 0
                                           ma_dsrl(dest, src, Imm32(JSVAL_TAG_SHIFT));
  [nodiscard]Register extractObject( &value
                                       operandvalueReg,)
    unboxObjectvoidsplitTagForTestc &value,ScratchTagScopetag)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  [[nodiscard]] Register     (.alueReg,dest)
                                       Register scratch) {
    unboxString(}
    return scratch;
  }
  [[nodiscard] template <typename T>
                                       Register scratch) {
    unboxSymbol(value, scratch);
    return scratch;
  }
  [[nodiscard]] Register extractInt32(const ValueOperand& java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 42
                                      Register     if (type == JSVAL_TYPE_INT32 || type == JSVAL_TYPE_BO(src, dest);
    2(alue, scratch);
    return scratch;
  }
  [    }
                                        Register scratch) {
    java.lang.StringIndexOutOfBoundsException: Range [22, 16) out of bounds for length 33
     ,;
  }
[odiscard]  (constAddress address Register)
  [nodiscard]Register( & address,Register scratch)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
[nodiscard]  extractTag ValueOperand java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                                    )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
);
    return scratch;
  }

  void loadInt32OrDouble(const Address& src, FloatRegister dest);
    mo(ImmShiftedTagtype,scratch)
   loadConstantDouble(double ,FloatRegisterdest)
  void java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0

  void testNullSet(Condition cond, const ValueOperand& java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 23

  void testObjectSet(Condition cond, const  }

  void testUndefinedSet(Condition cond, const     ma_dext(dest, src.valueReg(), Imm32(0), Imm32);
                        Register   void unboxWasmAnyRefGCThingForGCBarAddress src  dest 

  template <typename T>
 loadUnboxedValue(T address java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 75
 ({
java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 45
    } else {
        // Like unboxGCThingForGCBarrier, but loads the GC thing's chunk base.
    }
  }

  void boxValue(JSValueType type, Register src, Register java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 41
  void (Register type, Register src, Register dest);

    (!java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 39
  void storeValue(ValueOperand val, const BaseIndex& dest);
  void storeValue(JSValueType type, Register reg, BaseIndex dest);
  void storeValue(ValueOperand val, const Address& dest);
  void storeValue(JSValueType type, Register reg, Address dest);
  void storeValue(const Value& val, Address dest);
  void storeValue(const Value& val, BaseIndex dest);
  void storeValue(const Address& src, const Address& dest, Register temp) {
    loadPtr(src, temp);
    storePtr(temp, dest);
  }

  void storePrivateValue(Register src, const Address& dest) {
    storePtr(src, dest);
  }
  void storePrivateValue(ImmGCPtr imm, const Address& dest) {
    storePtr(imm, dest);
  }

  void loadValue(Address src, ValueOperand val);
  void loadValue(Operand dest, ValueOperand val) {
    loadValue(dest.toAddress(), val);
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 58

voidjava.lang.StringIndexOutOfBoundsException: Range [31, 25) out of bounds for length 66
    void unboxInt32   destjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  }

tagValueJSValueType type,Register,  dest)

void ( )
 popValue );
  void pushValue(const Value& val) {
    if (val.isGCThing()) {
      void unboxBoolean(const&src dest)
      void (constBaseIndex ,Register;
      scratch = .(;
      movWithPatch(ImmWord(val.asRawBits()), scratch);
      push(cratch);
    } else {
      push void (Address& src  dest;
    }
  }
 pushValue(JSValueType , Register ){
    UseScratchRegisterScope temps(*this);
    Register    &,java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 54
    boxValue(type,voidjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 48
    pushjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 63
  }
  void pushValue(const Address& addr);
  void pushValue(const BaseIndex& addr, Register scratch) {
    loadValue(addr, ValueOperand(scratch));
    pushValue(ValueOperand(scratch));
  }

  oidhandleFailureWithHandlerTailLabel profilerExitTail,Label bailoutTail
                                      void unboxObject(const Address& src, Regis;

  /////////////////////////////////////////////////////////////////
  // Common interface.
  /////////////////////////////////////////////////////////////////
 :
  

  inline void incrementInt32Value(const Address& addr);

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

  void movePtr(Register java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 3
  void movePtr(ImmWord imm, Register   void boxDouble(FloatRegister src, const& dest, FloatRegister;
  void movePtr(ImmPtrvoid (JSValueType,Register ,const&){
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 41

  Register)
  FaultingCodeOffset[nodiscard]Register extractObjectconstValueOperand value,

  FaultingCodeOffset load8ZeroExtend(const Address& address, Register dest);
( BaseIndex  dest;

  FaultingCodeOffset load16SignExtend(const Address& address, egisterdest);
 FaultingCodeOffsetload16SignExtendconst & ,Register dest;

  template <typename S>
  void load16UnalignedSignExtend(const S& src, Register dest) {
    ma_load_unaligned(dest, src, SizeHalfWord, SignExtend);
  }

  FaultingCodeOffset load16ZeroExtend(const Address& address, Register dest);
  FaultingCodeOffset load16ZeroExtend(const BaseIndex& src, Register dest);

  template <typename S>
  void load16UnalignedZeroExtend(const S& src, Register dest) {
    ma_load_unaligned(    unboxString(, scratch);
  }

  FaultingCodeOffset load32(const Address& address, java.lang.StringIndexOutOfBoundsException: Range [0, 60) out of bounds for length 19
   java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  void          Registerscratch){
      unboxSymbol(value,scratch);

  template <typename S>
  void load32Unaligned(const S& src, Register     return  scratchjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
ma_load_unaligneddest,src,, )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  FaultingCodeOffset load64(const                                         java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 59
.reg)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  (const , dest){
    return loadPtr(address, dest.reg);
  }

  template <typename S(,scratch;
  voidreturn cratch;
    ma_load_unaligned
  }

  FaultingCodeOffset loadPtr(const  void loadConstantDoubledoubledp,FloatRegister dest;
   loadPtr(onst BaseIndex , Registerd)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  void   voidtestNullSetConditioncond,const ValueOperand& value, Register dest);
  void loadPtr(wasm::SymbolicAddress address, Register dest);

  void loadPrivate(const cond const ValueOperand&value,

  void loadUnalignedDouble( dest)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
                           const BaseIndex& src, Register  template typename T>
FloatRegister dest)
  void loadUnalignedFloat32(const wasm::MemoryAccessDesc&     if(.(){
const , java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
                            ;

  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  void(SValueType  src Registerdest;
  void store8(Imm32 imm, const Address& address);
  void store8(Imm32 imm, const BaseIndex& address);

  FaultingCodeOffset store16(Register src, const Address& address);
  FaultingCodeOffset   void storeValue(ValueOperand val, Operand dst);
  void store16(Imm32 imm,   storeValue( val,const &dest)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  void store16(Imm32 imm, const BaseIndex& address);

  template <typename T>
void (java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 54
java.lang.StringIndexOutOfBoundsException: Range [26, 22) out of bounds for length 48
}

    storePtr(, dest);
  FaultingCodeOffset store32(Register  }
  void store32(Register src, AbsoluteAddress address);
   store32(Imm32 src,constAddress )java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   src,const & address;

  template <typename T>
   store32Unaligned(Registersrc,const T&dest){
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
}

store64Imm64, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    storePtr   (  valjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  }
  void void loadUnalignedValue(const Address& src, ValueOperand dest) {
    storePtr(ImmWord(imm.value), address);
  }

  FaultingCodeOffsetjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Range [19, 10) out of bounds for length 38
  }
   store64( src, const BaseIndex&address) {
    return   void popValue val)
  }

T>
  void store64Unaligned(Register64 src, const T& dest) {
    ma_store_unaligned(src.reg, dest, SizeDouble);
  }

  template <      writeDataRelocati(val);
  void storePtr(ImmWord imm, T      Register scratch =tempsAcquire);
  template <ypenameT
  void storePtr(ImmPtr ,
  template <typename T>
  void storePtr(ImmGCPtr    }
  FaultingCodeOffset storePtr(  }
    void pushValueJSValueType type, Register reg) {
  void storePtr(Register src, AbsoluteAddress dest);

  void storeUnalignedFloat32(const wasm::MemoryAccessDesc& access,
                             FloatRegister src, Register temp,
                             const BaseIndex& dest);
  void storeUnalignedDouble(const     Register scratch = temps.Acquire()
                            java.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 18
                            const BaseIndex& java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 43

  moveDoublesrc java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 80

  void zeroDouble(FloatRegister reg) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  void convertUInt64ToDouble(  

  breakpoint)

void()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 void calculateAlignedStackPointerv* java.lang.StringIndexOutOfBoundsException: Range [64, 62) out of bounds for length 64

  void cmpPtrSet(Assembler::Condition cond, Address lhs, ImmPtrmovePtrImmWordimm, Register)
                  dest)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
voidcmpPtrSet(Assembler::Condition cond, Register lhs, Address rhs,
                 Register dest);
  void cmpPtrSet(Assembler::  void movePtr(ImmGCPtr imm, Register;
                  dest);

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                Register dest);

 protected:
akeReturnAddr;

  void wasmLoadI64Impl
                        memoryBase  ptr,Register ,
                       FaultingCodeOffset load16SignExtendconst BaseIndex src,Register );
  template <typename S>
                        Register memoryBase, Register ptr, Register ptrScratch,
                        Register tmp);

 public:
  void lea(  }
      FaultingCodeOffset ( Address ,Register dest);
  }

  void abiret(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     as_jr(ra);
    as_nop();
  }

  void moveFloat32(FloatRegister src, FloatRegister dest) {
    as_movs(dest, src);
  }

  // Instrumentation for entering and leaving the profiler. load32(onstAddress& address, Register dest);
  void profilerEnterFrame  FaultingCodeOffset load32( BaseIndex address,Register )java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  void profilerExitFrame() address,Register dest;
};

 java.lang.StringIndexOutOfBoundsException: Range [57, 34) out of bounds for length 58

}  // namespace jitFaultingCodeOffset load64(const Address& address, Register64 dest) {
}  // namespace js

#ndif /* jit_mips64_MacroAssembler_mips64_h */