/* 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 ImmShiftedTag : public ImmWord {
  explicit ImmShiftedTag(JSValueType type)
      : ImmWord(uintptr_t(JSValueShiftedTag(JSVAL_TYPE_TO_SHIFTED_TAG(type)))) {
  }
};

struct ImmTag :   ( )
 ImmTagJSValueTag ):Imm32int32_tmask)){}
};

static constexpr}

taticconstintdefaultShift  3java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
static_assertstatic_assert(1<defaultShift== (:Value),
              "The defaultShiftis );

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

class // MacroAssembler-x64
  classScratchTagScope {
  ;
  bool owned_;
  mozilla::DebugOnly<bool> released_;

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

  operator Register  Register scratch_;
   owned_;
    return scratch_;
  }

  void release() {
!)
    released_ temps_Release);
    java.lang.StringIndexOutOfBoundsException: Range [14, 6) out of bounds for length 17
      temps_.Release if!wned_){
      owned_ = false;
    }
  }

  void reacquire() {
    MOZ_ASSERT(      scratch_ =.cquire)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 22
 ! 
java.lang.StringIndexOutOfBoundsException: Range [14, 6) out of bounds for length 34
 java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    }
  } public:
};

class ScratchTagScopeRelease {
  ScratchTagScope* ts_;

 public:
  explicit   using MacroAssemblerMIPSShared::ma_b;
    ts_->release();
  }
  ~ScratchTagScopeRelease() { ts_>reacquire(); }
};

class MacroAssemblerMIPS64 : public MacroAssemblerMIPSShared {
 public:
    usingusing MacroAssemblerMIPSShared::ma_ld;
  using MacroAssemblerMIPSShared::ma_cmp_set;
  using  MacroAssemblerMIPSSharedma_lijava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
java.lang.StringIndexOutOfBoundsException: Range [39, 32) out of bounds for length 40
usingjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 49
  MacroAssemblerMIPSShared
  using void ma_li(Register, imm;
  usingMacroAssemblerMIPSShared:java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  MacroAssemblerMIPSSharedma_ssjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  
  using MacroAssemblerMIPSShared::ma_sub32TestOverflow;

  void ma_li(Register dest, CodeLabel* label);
  void ma_li(Register dest,ImmWord imm);
  void ma_liPatchable(Register java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  void ma_liPatchable(Register   void ma_dsrl(Register rd, Register )

  // Negate
  void ma_dnegu(Register rd, Register rs);

  // Shift operations
  void ma_dsll(Register void ma_drol(Register rdjava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 54
voidma_dsrlR rd Registerrt shift;
  void ma_dsra(Register rd, Register rt, Imm32 shift);
  void (rd,Register ,Imm32shift)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  void ma_drol(Register rd,Register , )

  voidv (rd  t Register)
  void   void ( rd  ,Register )java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  void ma_dsra( ,Register rt  shift;
  void ma_dror(Register rd, Register rt, Register  ma_dextRegister rt rs ,Imm32 sizejava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  void ma_drol  void Register  java.lang.StringIndexOutOfBoundsException: Range [41, 36) out of bounds for length 41

  void ma_dins(Register rt,                              LoadSto  java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 59
 java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 64

  // doubleword swap bytes
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 41
  Registerjava.lang.StringIndexOutOfBoundsException: Range [39, 36) out of bounds for length 41

  void ma_dctz(Register rd, Register rs);

  // load
  FaultingCodeOffset                LoadStoreExtension extension=SignExtend);
                             LoadStoreSize size = SizeWord,
                               void ma_store(ImmWord imm, Address addresssize  SizeWord,

  // store ops
  FaultingCodeOffset java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 8
                              LoadStoreSize size    ma_dadduR   rs  );
                              java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 40
  voidImmWordimm  & dest
                LoadStoreSize size =                             Label* overflow)
                 extension  SignExtend;
  void ma_store(ImmWord imm, Address address, LoadStoreSize size                             *overflow;
                LoadStoreExtension extension = SignExtend
 
  // add
voidjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 53
java.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 46
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 42
  void ma_daddu(RegisterLabeloverflow;
  void ma_add32TestOverflow(Register rd,void Condition rd,Register,Imm32java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
Label;
  void ma_add32TestOverflow(Register rd, Register rs, Imm32 imm,
                            ,*java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 54
  void ,rs
                             LabelvoidR,;
void java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 65
                             Label*                              java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  void ma_addPtrTestOverflowRegister rd,Registerrs, ImmWord imm
                             Label* overflow);
  void (Condition cond,Register rd Register rs, Register rt,
                          Label* overflow);
  void ma_addPtrTestCarry(Condition   , java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 78
                          Label* overflow);
  (Condition,rd java.lang.StringIndexOutOfBoundsException: Range [68, 66) out of bounds for length 80
java.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 46
ed   ,java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 68
                             ma_pushr)
  void ( code *,JumpKind,
                       branchCodeScratchInvalidReg);
  void ma_addPtrTestSigned(  void ma_b(Register lhs, ImmWord( ,ImmWordimm *  c,
ImmWord imm *)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 42
  void)
  void ma_dsubu(Register rd, Register rs);
 voidma_dsubu(Register rd,Imm32 imm)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  void ma_sub32TestOverflow(Register rd, Register rs, Register rt,
                            Label* overflow);
  void ma_subPtrTestOverflow(Register rd, Register rs, Register rt,
                             Label* overflow);
  void ma_subPtrTestOverflow(Register rd, Register rs, Imm32 imm,
                             Label* overflow);

  // multiplies.  For now, there are only few that we care about.
void ,rs java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 55
, java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 55
  java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 69
                              java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

  // stack
  void(r
  void ma_push(    "s for this ";

  void   ( ,FloatRegister dest java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
Register branchCodeScratch = InvalidReg);
  // branches when done from within mips-specific code
  void ma_b(Register lhs, ImmWord imm, Label* l, Condition c,
            JumpKind   }
  void   void conv(java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 71
             (src  
  voidMOZ_CRASHNotsupportedthis)
            java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 3
  (ddress ddr ImmGCPtrimm *l  cjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
JumpKindjumpKind=LongJump;
  void ma_b(Address java.lang.StringIndexOutOfBoundsException: Range [2, 24) out of bounds for length 3
            jumpKind =LongJump)
    void computeScaledAddress32(const BaseIndex& address, Register dest);
    Register scratch = temps.Acquire();
    MOZ_ASSERT(rhs != scratch);
    ma_load(scratch, addr,     ma_daddu(dest, address.base, Imm32address.offset);
    ma_b(scratch, rhs, l, c, jumpKind);
  }

    void computeEffectiveAddressconst & ,Register );

  // fp instructions
  void java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 3

  void ma_mv(    computeScaledAddress32( )
  java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 51

java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  FaultingCodeOffset(*  (dest java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
(FloatRegisterft addressjava.lang.StringIndexOutOfBoundsException: Range [62, 63) out of bounds for length 62
FaultingCodeOffset ma_ssFloatRegisterft,Addressaddress)java.lang.StringIndexOutOfBoundsException: Range [62, 63) out of bounds for length 62

  void}
  void ma_push(FloatRegister f);

  void void mov(Register  ()java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  void
    voidwriteDataRelocation &val {
  voidma_cmp_set(Register dst, ddress address, Register rhs, Condition c);
  void ma_cmp_set(Register dst, Address address, ImmWord imm, Condition  // TraceOneDataRelocation.
  void ma_cmp_setRegister 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.
(Register src FloatRegister dest) { as_mthc1(src, dest); }
  void moveFromDoubleHi    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    as_mfhc1(   branch(itCode*c java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  }

  void moveToDouble(Register src, FloatRegister     addPendingJump(bo, ImmPtr(c->raw()), RelocationKind::JITCODE);
  voidmoveFromDouble(FloatRegister src, Register dest) { as_dmfc1(dest, src); }
};

class MacroAssembler;

class MacroAssemblerMIPS64Compat : public MacroAssemblerMIPS64as_nop(;
 public:
  usingMacroAssemblerMIPS64:;

  rMIPS64Compat() {}

  void convertBoolToInt32(Register sourceas_nop);
  void (Register ,FloatRegisterdest)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  nt32ToDoubleconstAddress ,FloatRegister dest)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  void convertInt32ToDouble BaseIndex& ,FloatRegister dest)
  void  return ;
  void convertUInt32ToFloat32(Register java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 3
  void void push(Imm32){
  void convertDoubleToInt32(FloatRegister src,      temps(*);
                           =;
  voidm(,
booljava.lang.StringIndexOutOfBoundsException: Range [50, 48) out of bounds for length 57
  java.lang.StringIndexOutOfBoundsException: Range [33, 27) out of bounds for length 41
                        =;

  void convertFloat32ToDoublescratchjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  UseScratchRegisterScope temps(*this);
  void convertInt32ToFloat32(const Address& src, java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 39

  void convertDoubleToFloat16(FloatRegister src, FloatRegister dest) {
    MOZ_CRASH("Not     ma_li(scratch, imm)
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
void( src dest)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    MOZ_CRASH(    (,scratchjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  }
   convertFloat32ToFloat16FloatRegistersrc dest 
    MOZ_CRASH("Not supported voidFloatRegister){(;
  }
  void convertFloat16ToFloat32(FloatRegister src, FloatRegister dest) {
    ("Not   target";
  }
  void convertInt32ToFloat16(Registerjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/
  }

  void  java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 39
    java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 56

  java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 71
    ma_daddu(dest, address.base/java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  }

  void computeEffectiveAddress(const}

  void(const & ,Registerdest java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    UseScratchRegisterScope temps(this);
  }

      Register scratch = temps.Acquire();
    computeScaledAddress32(address, dest);
    if (address.offset) {
    CodeOffset offset= movWithPatch(, )
    }
  }

 ;

  void 
 ,java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 60
  void mov(ImmPtr imm ma_liPatchable(,imm,Li64)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
mov((.alue)) ;
  }
  void mov(CodeLabel* CodeOffset offset = CodeOffset(currentOffset());
   src, Address dest  (NYIIC) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  void mov(Address src,  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

  void writeDataRelocation    label->patchAt(->bindcurrentOffset());
    MOZ_ASSERT(val.isGCThing(), "only called for gc-things");

    // Raw GC pointer relocations and Value relocations both end up in
//TraceOneDataRelocationjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    gc
    if (cell && gc::IsInsideNursery(cell)) {
      embedsNurseryPointers_ = true;
    }
    dataRelocations_.writeUnsigned(currentOffset());
    }

  void branch(JitCode* c) {
    UseScratchRegisterScope temps(*this);
    BufferOffset bo = m_buffer.nextOffset();
    addPendingJumptemplate typename >
    Register  =tempsAcquire(;
    ma_liPatchable(scratch, ImmPtr(c->raw(    MOZ_ASSERT( ! JSVAL_TYPE_DOUBLE)
       scratch)
    as_nop( load32src ;
  }
return;
    as_jr(reg);
    as_nop();
  }
  voidnop){ (;java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  BufferOffset ret() {
    ma_pop(ra);
    BufferOffset offset = as_jr(ra);
    as_nop();
    return offset;
java.lang.StringIndexOutOfBoundsException: Range [19, 3) out of bounds for length 3
  
java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 41
        as_xor(ds;
    ma_li(scratch, imm)}
    
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
ord java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    UseScratchRegisterScope temps(*this);
java.lang.StringIndexOutOfBoundsException: Range [20, 4) out of bounds for length 39
    ma_li(  java.lang.StringIndexOutOfBoundsException: Range [57, 41) out of bounds for length 78
    ma_push(scratch);
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
  void  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
     wasm:java.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 57
        (dest java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 32
    ma_lijava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 24
    ma_push(scratch);
  }
  void push(const Address& address*;
    UseScratchRegisterScope*java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 39
     java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 30
    ma_push(   (constValueOperand src Register dest) {
  }
  void push(Register reg) { ma_push(reg); }
  void push(FloatRegister reg) { ma_push(reg); }
  void pop(Register reg) { ma_pop(reg); }
  void (FloatRegister reg) { ma_pop(reg); }

  // Emit a branch that can be toggled to a non-operation. On MIPS64 we use
  // "andi" instruction to toggle the branch.
  // See ToggleToJmp(), ToggleToCmp().
  CodeOffsetsmAnyRefGCThingChunk(Register src,Register dest) {

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

   java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 48
   unboxInt32 &,Register)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
return6*sizeofuint32_t
  }

CodeOffsetpushWithPatch(mmWord){
    UseScratchRegisterScope temps(*this);
      void( &src, Registerdest;
    void unboxBoolean ValueOperand ,Registerdest)
    ma_push(scratch);
    return offsetvoid&,java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 55
  }

  CodeOffset movWithPatch(ImmWord imm, Register dest) {
    CodeOffsetoffset (currentOffset)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    ma_liPatchable;
    return offset   c &src  ;
  }
ImmPtr java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
   java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 52
    ma_liPatchable(dest, imm);
    return java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 54
  }

  void(CodeLabel label) {
    label->patchAt()->bind(currentOffsetunboxBigIntconstsrc dest;
->(:RawPointer;
    m_buffer.ensureSpace(sizeof(void unboxObject(Register src, Register dest);
    writeInstjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 57
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  void jump(Label* label) { ma_b(label); }
  void jump(Register     (.(,val.alueReg) ;
    as_jr(reg);
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
  }
  void  void boxNonDouble( type, Register src, const ValueOperand& dest) {
    UseScratchRegisterScope temps(*this);
    Register scratch = temps.Acquire();
    loadPtr(address, scratch);
    as_jr((scratch);
    as_nop();
  }

  void jumpJitCode* code) { branch(ode); }

r ptr){
    BufferOffset bo = m_buffer.nextOffset();
    java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
    ma_jump(ptr);
  }

voidjumpTrampolinePtr ){jump((codevalue); java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

  void splitTag(Register src, Register dest) {
java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  }

  void splitTag  []  extractObjectconstValueOperand ,
    splitTag(.() dest)
  }

   splitTagForTest(onstValueOperand value & ){
    splitTag(value, tag);
  }

  // unboxing code
  void unboxNonDouble(}
                      JSValueType type) {
    unboxNonDoubleoperandv() , type)
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 23
  voidjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 32
    MOZ_ASSERT(type != JSVAL_TYPE_DOUBLE);
OLEAN) {
      load32java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 24
      unboxInt3vjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
    loadPtr(src, unboxBoolean(value, scratch);
unboxNonDouble(dest,dest type);
  }

  void unboxNonDouble(Register src  [[]RegisterextractTag &, scratch;
  []  extractTagconstBaseIndexaddress  scratch;
    MOZ_ASSERT(type != JSVAL_TYPE_DOUBLE);
    if (type   [] Register(constValueOperand&value,
      ma_sll(dest, srcRegister scratch){
      return;
    }
    Register scratch =     splitTag(value, scratch
    MOZ_ASSERT(java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
v(),scratch;
    as_xor(dest,  voidloadConstantDouble(double dp  ;
  }

  void unboxGCThingForGCBarrier(const Address& java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    loadPtr(src, dest);
    ma_dext(dest, dest,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  }
  void java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
(JSVAL_TAG_SHIFT)
  }

rier(const & src,Register dest){
    UseScratchRegisterScope tempsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    Register scratch = temps.Acquire( void const &address, MIRType type,AnyRegister dest) {
    MOZ_ASSERT(scratch != dest);
        if(dest.isFloat)) {
      loadInt32OrDouble(address, dest.fpu());
    as_and(dest, dest, scratch);
  }


  void java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 5
    UseScratchRegisterScope temps(*this);
    Register scratch = temps.Acquire  voidboxValuejava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 60
    MOZ_ASSERT(scratch != dest);
    loadPtr(src, dest);
    movePtr(ImmWord(JS::detail::ValueGCThingPayloadChunkMask), scratch);
    as_and(dest, dest, scratch);
  }
  void getGCThingValueChunk(const ValueOperand& src, Register dest) {
MOZ_ASSERT(rc.valueReg() ! dest);
    movePtr(ImmWord(JS::detail::ValueGCThingPayloadChunkMask), dest);
    as_and(dest, dest, src.valueReg());
  }

  void getWasmAnyRefGCThingChunk  }
    MOZ_ASSERT(src != dest);
    movePtr(ImmWord(wasm::AnyRef::GCThingChunkMask), dest);
      void loadValue(constBaseIndex& addr, ValueOperand val);
  }

  void unboxInt32  void loadUnalignedValue(const Address& src, ValueOperand dest) {
  (Registersrc,Register dest);
  void unboxInt32(const Address& src, Register dest);
  void unboxInt32(  void tagValue( type Register payload ValueOperanddest;
    pushValueValueOperandval)
  void(ValueOperandval)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   Address ,Register dest;
   unboxBooleanconst &src  dest)
  void unboxDouble( Register =tempsAcquire)java.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
  void unboxDoublepush(cratch)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  unboxDoubleconst & ,FloatRegisterdest)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  void  void (JSValueTypetype Register reg java.lang.StringIndexOutOfBoundsException: Range [50, 51) out of bounds for length 50
  void unboxString(const ValueOperand& operand, Register dest);
  void unboxString(Register src, Register dest);
voidunboxString(const Address&src Register dest);
  void unboxSymbol(const ValueOperand& src, Register dest);
  void unboxSymbol(Register src, Register dest);
  void unboxSymbol(const Address& src, Register dest);
  void unboxBigInt(const ValueOperand& operand, Register dest);
  void unboxBigInt}
  void unboxBigIntjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 38
  java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 37
  void unboxObjectv (*profilerExitTail *,
ter dest)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  void java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
    unboxNonDouble// Common interface.
  }
  public

  void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    as_xorivoidjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 43
  }

  // boxing code
 ValueOperand )java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  boxNonDouble type  src  ValueOperand dest {
    boxValue(type, src, dest.valueReg());
  }
  void boxNonDouble(Register type, Register src, const ValueOperand& dest) {
    boxValue(type, src, dest.valueReg());
  }

  // Extended unboxing API. If the payload is already in a register, returns
  // that register. Otherwise, provides a move to the given scratch register,
  // and returns that.
  [[nodiscard]] Register extractObject(const Address& address,
                                        scratch;
  [] ( &,
                                       Register java.lang.StringIndexOutOfBoundsException: Range [48, 55) out of bounds for length 0
    unboxObject(valueload8ZeroExtendconst BaseIndex&src,Register dest)
    returnR ;
  }
    (BaseIndexsrc )
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
valuejava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    return scratch;
  }
  [[nodiscard]] Register extractSymbol(const ValueOperand& FaultingCodeOffsetload32(const BaseIndex& address, Register dest);
                               scratch 
 java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 32
;
  }
  [[nodiscard]] Register    ( src SizeWordSignExtend;
                                      Register scratch) {
    unboxInt32  }
    return scratch;
  }
  [[nodiscard]] Register java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
                                        Register scratch) {
    unboxBoolean(value, scratch);
    return scratch;
  }
  [[nodiscard]] Register     return loadPtr(address, dest;
  [[nodiscard]] Register extractTag(const}
  [[nodiscard]]   FaultingCodeOffset load64 BaseIndex&address Register64dest java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                                    java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    splitTagvalue, )java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    returns;
  }

  void}
  void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  void( dp FloatRegister dest)
  void loadConstantFloat32(float fFaultingCodeOffsetconst&src Register est;

 (  java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 77

  void

Condition,const java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                        Register ;

  <java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 23
  void                           ;
 (destisFloat) 
      loadInt32OrDouble(address, dest.fpu());                             BaseIndex&src Registertemp,
    } else {
      unboxNonDouble(address, FloatRegister dest)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    }
  }

   boxValue(SValueType type,Registersrc,  dest)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  void(immBaseIndexjava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 51

java.lang.StringIndexOutOfBoundsException: Range [30, 2) out of bounds for length 49
voidstoreValueValueOperand BaseIndex&;
  void storeValue(JSValueType type, Register reg, java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  void java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
  void storeValue(JSValueType  store16UnalignedRegister src, const T& dest) {
  void storeValue(const    ma_store_unaligned(src, dest, SizeHalfWord);
  void storeValue(const Value& val, BaseIndex dest);
  }
    loadPtr
temp ;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

    voidImm32  &address;
    storePtr(src, dest);
  }
  void   void store32(Imm32 BaseIndex )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    storePtrvoidstore32Unaligned( ,constT  {
  }

  void  }
  void loadValue  void store64( imm Address address){
    loadValue(dest.toAddress(), val);
  }
void loadValue(const BaseIndex&addr,ValueOperand val);

  java.lang.StringIndexOutOfBoundsException: Range [25, 6) out of bounds for length 66
    
  }

  void return storePtr(src.reg, address);

  void pushValue(FaultingCodeOffsetRegister64 const&address {
(ValueOperand )
  void pushValue(const   }
    if (val.  template <typename java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 50
onjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        .(;
      movWithPatch(ImmWord< >
      pushstorePtrImmPtrimm, T address);
    } else {
      push(ImmWord(val.java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

(java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 50
    UseScratchRegisterScope
;
    boxValue(type, reg, scratch);
    push(scratch);
  }
  void pushValue(const Address& addr);
  void pushValue(const BaseIndex& addr, Register scratch) {
    loadValue(addr, ValueOperand(scratch));
    pushValue(ValueOperand(scratch));
  }

  void handleFailureWithHandlerTail(Label  void (FloatRegister src,FloatRegister dest) { as_movd(dest, src); }
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0

  /////////////////////////////////////////////////////////////////
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
  /////////////////////////////////////////////////////////////////
 public
  void (;

  inline   checkStackAlignment;

  void move32
  void   staticvoidcalculateAlignedStackPointer(oid*stackPointer);

  void movePtr(Register java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 0
  void ( imm, dest;
  void movePtr(Register;
  void    java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 70
 dest)

Register
  FaultingCodeOffset

  FaultingCodeOffset load8ZeroExtend(const java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 31
  FaultingCodeOffset   bool buildOOLFakeExitFrame(void* f)

  FaultingCodeOffset load16SignExtendRegistermemoryBase,Registerptr,ptrScratch
  (& dest

java.lang.StringIndexOutOfBoundsException: Range [23, 24) out of bounds for length 23
  void load16UnalignedSignExtendtmp;
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  }

FaultingCodeOffsetload16ZeroExtendconst&address  dest)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  template <typename S>
     java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 14
    ma_load_unalignedjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 59
  }

  FaultingCodeOffset( java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 67
FaultingCodeOffsetload32const&  dest;
  void load32(AbsoluteAddress address, Register dest);
  void load32(wasm::SymbolicAddress Register dest)

  template <typename S>
  void load32UnalignedtypedefMacroAssemblerMIPS64Compat MacroAssemblerSpecific;
    ma_load_unaligned(dest, src, SizeWord, SignExtend);
  }

  java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 70
    return loadPtr#/* jit_mips64_MacroAssembler_mips64_h */
  }
  FaultingCodeOffset load64(const BaseIndex& address, Register64 dest) {
    return loadPtr(address, dest.reg);
  }

  template <typename S>
  void load64Unaligned(const S& src, Register64 dest) {
    ma_load_unaligned(dest.reg, src, SizeDouble, ZeroExtend);
  }

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

  void loadPrivate(const Address& address, Register dest);

  void loadUnalignedDouble(const wasm::MemoryAccessDesc& access,
                           const BaseIndex& src, Register temp,
                           FloatRegister dest);
  void loadUnalignedFloat32(const wasm::MemoryAccessDesc& access,
                            const BaseIndex& src, Register temp,
                            FloatRegister dest);

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

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

  template <typename T>
  void store16Unaligned(Register src, const T& dest) {
    ma_store_unaligned(src, dest, SizeHalfWord);
  }

  FaultingCodeOffset store32(Register src, const Address& address);
  FaultingCodeOffset store32(Register src, const BaseIndex& address);
  void store32(Register src, AbsoluteAddress address);
  void store32(Imm32 src, const Address& address);
  void store32(Imm32 src, const BaseIndex& address);

  template <typename T>
  void store32Unaligned(Register src, const T& dest) {
    ma_store_unaligned(src, dest, SizeWord);
  }

  void store64(Imm64 imm, Address address) {
    storePtr(ImmWord(imm.value), address);
  }
  void store64(Imm64 imm, const BaseIndex& address) {
    storePtr(ImmWord(imm.value), address);
  }

  FaultingCodeOffset store64(Register64 src, Address address) {
    return storePtr(src.reg, address);
  }
  FaultingCodeOffset store64(Register64 src, const BaseIndex& address) {
    return storePtr(src.reg, address);
  }

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

  template <typename T>
  void storePtr(ImmWord imm, T address);
  template <typename T>
  void storePtr(ImmPtr imm, T address);
  template <typename T>
  void storePtr(ImmGCPtr imm, T address);
  FaultingCodeOffset storePtr(Register src, const Address& address);
  FaultingCodeOffset storePtr(Register src, const BaseIndex& address);
  void storePtr(Register src, AbsoluteAddress dest);

  void storeUnalignedFloat32(const wasm::MemoryAccessDesc& access,
                             FloatRegister src, Register temp,
                             const BaseIndex& dest);
  void storeUnalignedDouble(const wasm::MemoryAccessDesc& access,
                            FloatRegister src, Register temp,
                            const BaseIndex& dest);

  void moveDouble(FloatRegister src, FloatRegister dest) { as_movd(dest, src); }

  void zeroDouble(FloatRegister reg) { moveToDouble(zero, reg); }

  void convertUInt64ToDouble(Register src, FloatRegister dest);

  void breakpoint();

  void checkStackAlignment();

  static void calculateAlignedStackPointer(void** stackPointer);

  void cmpPtrSet(Assembler::Condition cond, Address lhs, ImmPtr rhs,
                 Register dest);
  void cmpPtrSet(Assembler::Condition cond, Register lhs, Address rhs,
                 Register dest);
  void cmpPtrSet(Assembler::Condition cond, Address lhs, Register rhs,
                 Register dest);

  void cmp32Set(Assembler::Condition cond, Register lhs, Address rhs,
                Register dest);

 protected:
  bool buildOOLFakeExitFrame(void* fakeReturnAddr);

  void wasmLoadI64Impl(const wasm::MemoryAccessDesc& access,
                       Register memoryBase, Register ptr, Register ptrScratch,
                       Register64 output, Register tmp);
  void wasmStoreI64Impl(const wasm::MemoryAccessDesc& access, Register64 value,
                        Register memoryBase, Register ptr, Register ptrScratch,
                        Register tmp);

 public:
  void lea(Operand addr, Register dest) {
    ma_daddu(dest, addr.baseReg(), Imm32(addr.disp()));
  }

  void abiret() {
    as_jr(ra);
    as_nop();
  }

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

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

typedef MacroAssemblerMIPS64Compat MacroAssemblerSpecific;

}  // namespace jit
}  // namespace js

#endif /* jit_mips64_MacroAssembler_mips64_h */