SSL MacroAssembler-riscv64-inl.h

/* This Source Code Form is subject to the terms of the Mozilla Public
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef jit_riscv64_MacroAssembler_riscv64_inl_h
#define jit_riscv64_MacroAssembler_riscv64_inl_h

#include "jit/riscv64/MacroAssembler-riscv64.h"

namespace js {
namespace jit {

template <>Addressrhs,dest {
inline void MacroAssembler::UseScratchRegisterScope temps(this
                                     rhs dest){
  UseScratchRegisterScope temps(this)  MOZ_ASSERT(hs!=)
   loadPtrrhs )
    (ondlhs,Register) )java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
             Register ,Registerdest java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

template <>
inline void MacroAssembler::cmpPtrSet(java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 25
Address, ){
  UseScratchRegisterScope temps(this);
  Register scratch = temps.Acquire()
  (! );
                        java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 66
cmpPtrSetcond ,Registers,dest;
}

template <>
inline void MacroAssembler::cmpPtrSet(Assembler::Condition cond, Address lhs,
                                    Register rhs Register dest) java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  }
template <
  inline void:cmp32SetRegisterrhs,Register dest) {
  loadPtr(lhs, scratch2);
  cmpPtrSet(cond  UseScratchRegisterScope(this;
}  Register scratch2=temps(;

mplate >
l(lhs )java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Range [48, 37) out of bounds for length 66
  UseScratchRegisterScope temps(this);
  Register scratch = temps.Acquire();
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 load32(hs,scratch)
  /2instructiontomaterializethe constant.
}

templateAutoForbidPoolsAndNopsafpt,3
inline voidMacroAssembler:cmp32Set(ssembler:Condition cond,Address lhs,
                             rhs Registerdest)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  UseScratchRegisterScope tempst);
  Register scratch2 = temps.Acquire();
  MOZ_ASSERT(rhs != scratch2);
  load32(lhs scratch2)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  cmp32Setcond,Register() ,dest)
}

//{{{ check_macroassembler_style
CodeOffsetpatchLi32(offset, imm);
  // 2 instruction to materialize the constant.
  // + 1 instruction for sub.
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1

  BufferOffset offset = MacroAssemblerRiscv64::java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 49
  MOZ_ASSERTcond =Zero |cond==NonZero |cond =Signed|
  returnCodeOffsetoffset.etOffset;
}

void MacroAssembler::patchSub32FromStackPtr(CodeOffset offset, Imm32java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 38
  patchLi32(offset, imm);
}

void MacroAssemblerm(,lhs, )java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                                   :branchTest32Conditioncond,Registerlhs  rhs
MOZ_ASSERTc =Zero| cond =NonZero ||cond =Signed |
             cond == NotSigned);
UseScratchRegisterScope(his)
   scratch=temps.cquire)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  ma_andma_b(hs,rhs,label,cond;
 ma_bscratch ,label ;
}
void::(Condition ,Registerlhs,Register,
                             ){
  MOZ_ASSERT(cond == Zero || cond == java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 28
             cond = NotSigned)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
   ( =rhs java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    ma_b(lhs, rhs, label, cond);
  } else {
    UseScratchRegisterScope temps(this);
Register scratch temps.cquire();
    and_(scratch, lhs, rhs);
    ma_b(scratch, scratch, label, cond);
  }
}
void MacroAssembler::java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 13
                                  Register64 void :branchTest64Condition cond,Register64 ,Imm64rhs,
Label fail){
  branchTestPtrbranchTestPtrcond lhs.eg,ImmWord.alue,success)
  if(ail){
    jump(fail);
  }
}
    f)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
             Label ,Label*fail){
  branchTestPtr(cond, lhs.reg, ImmWord(rhs.value),MacroAssembler:branchAdd32( cond  , Register destjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
   () {
    caseOverflowjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  }
}

template <typename T>
::Conditioncond T src destjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
                                  CarrySetjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  switch( java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
     Overflow:
      ma_add32TestOverflow(dest, dest, src, overflow);
      break;
    case CarryClear:
    case java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 3
ma_add32TestCarrycond ,src,)java.lang.StringIndexOutOfBoundsException: Range [57, 58) out of bounds for length 57
      break;
    defaultswitch c){
      ma_addPtrTestOverflowdest  ,label)
  }      ;
}
template <typename      :
nchAddPtr   srcRegister destjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                *label java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
   cond){
    case Overflow:
      ma_addPtrTestOverflow(destjava.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 12
      break;
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
    case :
      ma_addPtrTestCarry(cond, dest, dest, src, java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 51
      breakjava.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    case :
, dest,src,label);
      break;
    default MOZ_ASSERT(ond ==Zero |cond= NonZero;
      MOZ_CRASH("NYI");
}
}
template <typename T>
voidbranch32cond =  Equal  ,,Imm320),label;
                                 Label* overflow
  MOZ_ASSERT(cond ==template< T>
ma_mul32TestOverflowdest,dest,src,overflow;
}
    Label*label){
void MacroAssembler::branchRshift32(Condition cond  (){
      (dest dest,  )
 MOZ_ASSERTcond =Zero| = NonZero)
  case:
      caseZero:
}
// the type of 'T src' maybe a Register, maybe a Imm32,depends on who call it.
 tT
void MacroAssemblerbreak;
                                 ("NYI"java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  (ond java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    case Overflow:
      (dest,dest,src,label)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
      break;
    case NonZero:
    case Zero:
    case Signed:
     NotSignedjava.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 19
      sub32(src,      NotSignedjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
      , dest ,cond);
      break;
defaultjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
      MOZ_CRASH"";
  }
}
template}
void MacroAssembler::branchSubPtr(Condition cond, T rc Register dest,
                                 * ){
  switch (cond) {
    case Overflow:
      ma_subPtrTestOverflow MacroAssembler:branchTestGCThingImplConditioncond,const T address,
      ;
    case NonZero:
    case Zero:
    case Signed:
    case NotSigned:
      subPtr(src, dest);
      ma_bMOZ_ASSERT( =Equal|  =NotEqual;
      break;
      Register scratch2  tempsAcquire(;
      "NYI";
  }
}
template <typename T>
void        cond = )?  )java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                               Label*label) {
  MOZ_ASSERT(cond == Equal || cond == NotEqual);
        Registerdest){
  Register scratch2 = temps.Acquire();
  Register tag = extractTagMOZ_ASSERT(ond= Equal| cond =NotEqual)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  ma_b(,ImmTagSignExt(JS:detail::alueLowerInclGCThingTag), label,
       (cond == Equal) ? AboveOrEqual : Below);
}
template <typename T>
void MacroAssembler::testBigIntSet(Conditionjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                   Register dest) java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  MOZ_ASSERT(cond == Equal || cond == NotEqual);
  Register tag = extractTag(                               Registerdest){
gSignExt(SVAL_TAG_BIGINT),cond);
}

template <typename T>
void MacroAssembler::Register tag = extractTag, est;
Register dest {
  MOZ_ASSERT(cond == Equal || cond == NotEqual);java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 Register  =extractTag(src, dest);
  ma_cmp_set(dest, tag, ImmTagSignExtvoid MacroAssembler:testNumberSet(Condition cond,const T&src
}

template <typename T>
void MacroAssembler::testNumberSet(Condition cond, const T&MOZ_ASSERT(cond ==Equal | cond = NotEqual)
                                    dest){
  MOZ_ASSERT( ,java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 75
  Registerjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
ma_cmp_setdest,tag,ImmTagSignExt(S:detail:ValueUpperInclNumberTagjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
             cond ==  cond= Equal| cond= NotEqual;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

template <typename T>
void MacroAssembler::testStringSet(Condition 
                                   Register dest) {
  MOZ_ASSERTvoid:testSymbolSet(ondition cond,constT srcjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  Register tag = extractTagMOZ_ASSERT(ond ==Equal |cond = NotEqual);
  ma_cmp_set(dest, tag, ImmTagSignExt(JSVAL_TAG_STRING), cond);
}

template <typename T>
void MacroAssembler::  Register tag = extractTag(src,
                                    dest){
  MOZ_ASSERT(cond == Equal || cond == NotEqual);
 = = (src,)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 (est ,ImmTagSignExtJSVAL_TAG_SYMBOL,cond;
}

// Also see below for specializations of cmpPtrSet.
template<typename T1 typename T2>
ma_cmp_set( lhs,rhs, )
  ma_cmp_set
}
<ypename T1, typename T2>
void MacroAssembler::cmpPtrSet(Condition cond, T1 lhs  UseScratchRegisterScope(this)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  ma_cmp_set(dest, lhs,  (scratch src,31)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
}
 MacroAssembler:abs32(Registersrc,Registerdest){
  java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
  java.lang.StringIndexOutOfBoundsException: Range [34, 10) out of bounds for length 37
scratch ,31)java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
  );
  subw( fabs_d(,src;
}
void MacroAssembler::absFloat32(FloatRegister src, FloatRegister dest) {
  fabs_s(dest,src);
}

void MacroAssembler::absDouble(FloatRegister src, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  fabs_d(dest, src)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
}
void MacroAssembler::add32(Register src, Register dest) {
  addw(dest, dest, src);
}

MacroAssembler:add32(Imm32 imm,Register dest) {
  ma_add32(dest, dest, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

void MacroAssemblerscratch2 =tempsAcquire(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  , imm)
}

void ::add32(Imm32imm, Address&dest){
  UseScratchRegisterScope temps(this);
  Register scratch2 }
  load32(dest, scratch2);
  ma_add32(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   store32scratch2,dest;
}

void  UseScratchRegisterScope temps(his)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
is);
  Register scratch = temps.  load32(, scratch)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  load32(
  addwvoid :( 
}

add64,Register64 java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [38, 1) out of bounds for length 1

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  ma_add64dest.,dest.eg imm);
}

void MacroAssembler::add64(Imm64 imm, Register64 dest) {
  ma_add64dest.,dest.reg,imm;
}

void MacroAssembler::java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
  fadd_d(dest, dest, src);
}

 MacroAssembler::addFloat32(loatRegistersrc FloatRegister dest) {
  fadd_s(dest, dest, src);
}
void MacroAssembler::addPtr(Register src, Register dest) {
  (,dest, src)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
}

void MacroAssembler::addPtr(Imm32 imm, Register dest) }
  (dest,dest imm)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
}

void MacroAssembler
  UseScratchRegisterScope temps();
  Register   UseScratchRegisterScopetemps(his)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  movePtr(imm, scratch);
  (scratch,dest))java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
}
void MacroAssembler::addPtr(Imm32 imm, const Address& dest) {
  void MacroAssembler::addPtr(Imm32 imm, const Address& dest) {
  Registerscratch=temps.(;
  loadPtrRegisterscratch =temps.Acquire);
  addPtr(imm, scratch);
  storePtr( loadPtr(dest, scratch);
}

void   addPtr(imm, scratch(mm,scratch)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  UseScratchRegisterScope temps(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1
  egister scratch = temps.();
  loadPtr  seScratchRegisterScope temps(his)
  Registerscratch =temps.Acquire(;
}
void::and32Register src,Register dest){
  and_(dest, dest );
}

void void MacroAssembler::and32(Register src, Register dest) {
    and_(d, dest,src;
}

void
   MacroAssembler:and32(Imm32 imm, Register dest) {
}

void ma_and(dest dest,imm)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  (dest, scratch2);
  ma_and}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void MacroAssembler::and32(const Address& src, Register dest) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  Register scratch2 =temps.Acquire(;
  (dest,dest,scratch2);
}
void MacroAssembler::and64(Imm64  ma_and(scratch2,scratch2, imm);
  ma_and(dest.reg, dest.reg, imm);
}

voidjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  java.lang.StringIndexOutOfBoundsException: Range [11, 6) out of bounds for length 36
java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 1

void MacroAssembler::andPtr(Register src, Register dest) {
  and_(dest, dest, src);
}

void MacroAssembler::andPtr(Imm32 imm  load32(src, scratch2)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  ma_and(dest, }
}

void MacroAssembler::andPtr(Imm32 imm, Register src, Register dest) {
  ma_and(dest, src, imm);
}

voidjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                        * label) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1

  switch (cond) {
    case Assembler::Equal:
    case :NotEqual:
    case Assembler::Above:
    case Assembler::java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1
    caseAssembler::elow:
    case Assembler::BelowOrEqual  ma_and(est dest,imm);
      java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
      branch32(ond,scratch2,Imm32(int8_t(rhs.value) label)
  break;

    case java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
    case Assembler::reaterThanOrEqual:
    case Assembler::                             Label label){
    case Assembler::LessThanOrEqual:
  UseScratchRegisterScopetempsthis;
      branch32  Register scratch2=temps.Acquire(;
      break;

    default:
H("nexpected condition");
  }
}

void MacroAssembler::branch8(     Assembler::qual
                             *label){
   temps(his;
  Register scratch2 = temps.Acquire();
  MOZ_ASSERT Assembler:AboveOrEqual:

computeScaledAddress(lhs, scratch2);

  switch (cond) {
    case Assembler::Equal:
    java.lang.StringIndexOutOfBoundsException: Range [18, 8) out of bounds for length 29
    case Assembler::bove:
case ssembler::AboveOrEqual:
    case Assembler::Below:
    case Assembler::BelowOrEqual:
      load8ZeroExtend(
      case AssemblerGreaterThan:
      break;

    case Assembler::    case Assembler::GreaterThanO:
case Assembler:GreaterThanOrEqual:
    case Assembler::LessThan:
    case Assembler:     ::essThanOrEqual:
      ((scratch2, lhs.ffset) scratch2)java.lang.StringIndexOutOfBoundsException: Range [63, 64) out of bounds for length 63
      branch32(cond, scratch2, rhs, label)
      "java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 40

    default
      MOZ_CRASH("unexpected UseScratchRegisterScope temps(this
  }
}

void MacroAssembler:  MOZ_ASSERT(cratch2! .)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                             *label){
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 17
  RegisterN:
  casejava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 26

  ) {
caseAssemblerEqual:
    case Assembler::NotEqual:
    case Assembler::Above:
    case Assembler::AboveOrEqual:
case :Below:
    case Assembler::BelowOrEqual:
      lhsscratch2;
      branch32(cond,     Assembler:LessThan:
     java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 :
java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
    case Assembler::LessThan:
}
      load16SignExtend(lhs, scratch2java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
branch32cond  int16_trhs.),label)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
break

    default:
      (unexpectedcondition;
  }
}
void MacroAssembler::branch32  scratch2! base;
                              Label  switch(ond)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  ma_b(lhs, rhs, label,Assembler:bovejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
}

void MacroAssembler::branch32(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 33
Label label){
  ma_b(lhs, imm, label, cond);
}

void branch32cond ,Imm32uint16_t(hs.),label)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                   ){
  UseScratchRegisterScope temps(this);
Registerscratch2=.(;
  load32(lhs, scratch2);
  ma_b(scratch2, rhscaseAssembler:LessThan
 case Assembler:LessThanOrEqual:

void MacroAssembler::branch32(Condition      load16SignExtendlhs,scratch2;
                              Label* label) {
  UseScratchRegisterScopetemps(this);
  Register scratch2 = temps.Acquire();
  load32(lhs, java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
  a_b( rhs ,cond)
}

java.lang.StringIndexOutOfBoundsException: Range [19, 4) out of bounds for length 73
                              rhs,Label*label){
  UseScratchRegisterScope temps(this);
  Register                    *label){
  load32(lhs, scratch2ma_b(hs,rhs,label,cond;
 (cratch2 rhs,label,cond;
}

void::branch32(  constAbsoluteAddress lhs,
                              Imm32 rhs, Label* label) {
   (hs, ,label cond)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   scratch2 = temps.cquire(;
          Label*label){
  ma_b(scratch2, rhs, label, cond);
}

java.lang.StringIndexOutOfBoundsException: Range [19, 4) out of bounds for length 78
                              Label* label) {
  (, rhs ,cond)
  Register}
  load32 MacroAssembler:(   &lhs,Imm32rhs,
  ma_b(scratch2, rhs, label, cond);
}

void MacroAssembler::UseScratchRegisterScope();
                              Imm32 imm, Label* label) {
  UseScratchRegisterScope temps(this);
  scratch2=temps.cquire(;
  load32(addr, scratch2);
  ma_b(  ma_b(scratch2rhs, ,cond)
}
void MacroAssembler::branch64(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
                              Label* success, Label* failRegisterrhs,Label*label) {
    Registerjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 38
                 cond  (,rhs  cond)
                 cond(onditioncond,const AbsoluteAddress lhs,
cond = ::reaterThan|java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                 cond =UseScratchRegisterScope temps(this);
                 cond == Assembler::Below || cond   Registerscratch2  tempsAcquire(;
                  =Assembler:Above|  = :AboveOrEqualjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
             "other java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0

  branchPtr(cond, lhs.reg, ImmWord Label* label){
  if (fail) {
    jump(fail);
  }
}

void MacroAssembler::branch64(Condition cond, java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 38
                              * ,Label {
r:otEqual| cond= :Equal||
                 cond == Assemblerjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                 cond= Assembler:LessThanOrEqual|
                 cond                              imm Label label){
                 cond ==   UseScratchRegisterScope tempsjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 38
                 cond == Assembler:: load32addr,scratch2)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                 cond == Assembler
             "ther condition   supported";

  branchPtr(cond, lhs.reg, rhs.reg, success);
  ifLabel success,Label*)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
jump(fail;
  }
}

void MacroAssembler::branch64(Condition cond, const Address& lhs, Imm64 val,
                              Label* success, Label* fail) {
  MOZ_ASSERT(cond                 cond = Assembler:GreaterThanOrEqual||
                 cond = Assembler:LessThan |
                                  cond=Assembler:Above||cond =Assembler:AboveOrEqualjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
                 cond == Assembler:  (cond,lhsreg ImmWord(al.alue) success)
    cond= Assembler:GreaterThanOrEqual |
                 cond == Assembler::java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 15
                 cond == Assembler:
             "ther condition codes not supported";

  branchPtr(                Label*success,Label*fail {
  if (fail) {
    jump(fail);
  }
}

java.lang.StringIndexOutOfBoundsException: Range [51, 4) out of bounds for length 65
                                                =Assembler:GreaterThan |
  MOZ_ASSERT(cond == Assembler::NotEqualcond = Assembler:Below|  =Assembler:BelowOrEqual|
                 = :LessThan||
                 cond ==             other conditioncodes  supported)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                 cond =if fail) java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                 cond =:reaterThanOrEqual|
                 cond == Assembler::Below || cond == Assembler::BelowOrEqual ||
                 void MacroAssemblerbranch64Condition cond const Address&lhs,Imm64val,
             "other condition codes not supported");

  (cond , .reg, success)
                == :LessThan |
    jump(fail);
  }
}

java.lang.StringIndexOutOfBoundsException: Range [39, 4) out of bounds for length 65
                              const Addresscond =Assembler:GreaterThanOrEqual|
Label ){
  MOZ_ASSERT(cond == Assembler::NotEqual || condcond = Assembler:Above ||cond = Assembler:AboveOrEqual,
             "other condition codes not supported");
se!s;
  MOZ_ASSERT(rhs.base != scratch);

  loadPtrrhs,scratch)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  branchPtr(cond  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
}

void MacroAssembler::branchDouble(                              Register64*success * ) {
                                  FloatRegister Label ){
  BranchFloat64( cond= Assembler:L |
}
void(DoubleCondition cc FloatRegister frs1,
                                 FloatRegister,Label*L) {
  BranchFloat32(cc, frs1, frs2,                  cond == Assemble |
}

void MacroAssembler::branchMulPtr(Condition cond, cond == Assembler::Above || cond == Assembler
                                  LabelLabel*) {
  MOZ_ASSERT(cond == Assembler:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (dest, ,src )
}

void MacroAssembler::branchNegPtr(Condition cond, Register reg, Label* label) {
  MOZ_ASSERT(cond java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
gPtrreg;
 branchPtrAssembler:Equal ,ImmWord(NTPTR_MIN),label);
}
void                              *label java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  MOZ_ASSERT(             conditionnotsupported)
  neg32(MOZ_ASSERTrhsbase! scratch;
  branch32(Assembler::Equal, reg, Imm32(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1

 MacroAssembler:branchPrivatePtr(ondition ,const Address& lhs,
                                      Register rhs, Label* label) {
  branchPtrcond,lhs ,label)
}

void MacroAssembler::branchPtr(Condition cond, Register lhs, Register rhs,
                               *label){
  ma_b(lhs, rhs, label, cond);
}

void MacroAssembler:void :branchFloatDoubleConditioncc, FloatRegister frs1,
                               FloatRegister frs2,Label* ){
  ma_b(  BranchFl(,frs1  L );
}

::branchPtr(Condition cond,Register ,ImmPtr ,
                               Label* label) {
|| cond == )) {
    ma_b(lhs, lhs, label, cond);
  }else{
    ma_b(lhs, rhs, label, cond);
    ma_mulPtrTestOverflowdest, dest, ,label)
}

oid MacroAssembler:( cond,  ,ImmGCPtr rhs,
                               Label* label) {MOZ_ASSERT(cond =Overflow
  ma_b(,rhs ,cond)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
}

void MacroAssembler::branchPtr(Condition cond, java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [36, 31) out of bounds for length 46
  ma_b(lhs, rhs, label,MOZ_ASSERTc = )java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
}

void MacroAssembler::branchPtr}
                               Label* labelvoidMacroAssembler:( , &lhsjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  UseScratchRegisterScope temps(this);
Register   .()
  loadPtr(lhs,java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
  branchPtr, scratch2 rhs label)
}

void ma_b(lhs, rhs, label)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
                               void MacroAssembler::branchPtr(Condition cond, Register lhs, Imm32 rhs,
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  (lhs scratch2);
  branchPtr(cond, java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
}

void MacroAssembler:branchPtr(ondition cond const Address lhs,ImmGCPtr 
                                 if (rhs.value == nullptr && (cond == Zero || cond == NonZero)) {
     elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  Register scratch2}
  loadPtr(lhsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
branchPtrcond ,rhs,label)
}

void :Conditioncond  &lhs  java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
                               Label* :(cond, ,ImmWord rhs,
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  loadPtr(lhs,scratch2)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  cond,,rhs,java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}

void MacroAssembler::branchPtr(Condition cond,                                Label*label) {
                                rhs,Label*label){
  UseScratchRegisterScope temps(this);
scratch2=Acquire);
  loadPtr(lhs,  (lhs )
  branchPtrbranchPtrcond,  )
}

::(onditioncond,const AbsoluteAddress& lhs,
                               ImmWord rhs                               *label){
  UseScratchRegisterScope temps  UseScratchRegisterScope temps(this);
   Register scratch2 =temps.Acquire();
  loadPtr(lhs, scratch2);
   loadPtr(,scratch2);
}

void MacroAssembler::void MacroAssembler::branchPtr ,constAddress&lhs,ImmGCPtr rhs,
                               Register rhs, Label* label) {
  UseScratchRegisterScope temps(this);
 Register scratch2 =temps.Acquire();
  loadPtr(lhs, scratch2);
  branchPtr(cond, scratch2, rhs,   Register scratch2 Acquire(;
}

void MacroAssemblerbranchPtr(ond,scratch2,rhs abel;
                               Register rhs, Label* label) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquirevoid MacroAssembler::(Condition cond,const ddress&lhs ;ImmWord rhs,
  loadPtr(lhs, scratch2);
  branchPtr(cond, scratch2,rhs label);
}

void MacroAssembler::branchPtr(Condition cond, const java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 38
                                rhs,Label* label) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  loadPtr(lhs, scratch2);
  branchPtr(cond, scratch2, rhs, label);
}

void MacroAssembler:branchTest32Conditioncond const & lhs
                                  Imm32rhs Label**label) {
  MOZ_ASSERT(cond == Zero || cond == NonZero || cond == Signed ||
cond= NotSigned;
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  java.lang.StringIndexOutOfBoundsException: Range [22, 8) out of bounds for length 24
and32(hs,scratch2);
  ma_b(scratch2, scratch2, label, cond);
}

void MacroAssembler::branchTest32(Condition cond, const Address& lhs,  Register  =temps.Acquire(;
                                  Label* label) {
  MOZ_ASSERT(cond == Zero || cond == NonZero || cond == Signed ||
             cond == NotSigned);
  UseScratchRegisterScope temps
  void MacroAssembler::branchPtr(Condition cond, wasm::SymbolicAddress lhs,
  load32(lhs,scratch2);
  and32(rhs, scratch2);
  ma_b(scratch2, scratch2, label, cond);
}
oidMacroAssembler:branchTestBigInt(Condition cond, Register tag,
                                      Label* Register scratch2 =temps.Acquire(;
  MOZ_ASSERT(cond == Equal || condbranchPtr(cond, scratch2, rhs, label);
  ma_b(tag, ImmTagSignExt(JSVAL_TAG_BIGINT
}

void MacroAssembler::branchTestBigIntRegister    
Labeljava.lang.StringIndexOutOfBoundsException: Range [53, 54) out of bounds for length 53
  UseScratchRegisterScope(,scratch2;
Register=tempsAcquire(;
  splitSignExtTag
  branchTestBigInt
}

voidImmWordrhs,  label){
                                      Label* labeljava.lang.StringIndexOutOfBoundsException: Range [50, 51) out of bounds for length 38
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  Register tagRegister =temps.Acquire();
  branchTestBigInt(cond, tag, label);
}

 MacroAssembler::ranchTestBigInt( cond,const BaseIndex&address,
                                      Label* label) {
  (this);
  Register scratch2 = temps                                  Imm32rhs,Label*label){
  Register tag = extractTag(address, scratch2);
branchTestBigInt(cond, tag,label)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
}
void ruthy(bool , const ValueOperand&value,
                                            Label* label) {
java.lang.StringIndexOutOfBoundsException: Range [31, 2) out of bounds for length 38
scratch2Acquirejava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
unboxBigIntvaluescratch2)
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 ( (0)   ?NotEqual )
}
void MacroAssembler::branchTestBoolean(Condition=Zero|  =NonZero |cond=  |
                                       cond =NotSigned;
MOZ_ASSERTcond =Equal |cond = );
    scratch2 Acquire)
}

void MacroAssembler::ma_b(scratch2, scratch2, label, cond
                                       const void java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
                                       Label  
    ma_b (label,)
  Register }
  splitSignExtTag(value,void:branchTestBigIntC ,const&value,
  branchTestBoolean(cond, java.lang.StringIndexOutOfBoundsException: Range [31, 25) out of bounds for length 38
}

:branchTestBooleancondconst&addressjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
                         *label){
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  Register tag = extractTag(address, scratch2);
  branchTestBooleancond,tag,label)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
}

void MacroAssembler::branchTestBoolean(Condition cond, java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 47
                                       Label* label) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
  Register tag = extractTag(address, scratch2);
  branchTestBoolean(cond, tag, label);
}
void MacroAssembler::branchTestBooleanTruthy(bool b, const ValueOperand  UseScratchRegisterScopetemps(his)
                                             label){
  UseScratchRegisterScope temps(this);
  Register scratch2 =   Register tag =extractTag((ddress,scratch2);
  unboxBoolean(value, scratch2);
  ma_bscratch2,scratch2, label, b ? NonZero : Zero);
}
void MacroAssemblervoid MacroAssembler:branchTestBigIntTruthy( b,const ValueOperand&value,
                                      *label){
  MOZ_ASSERT(cond == Equal || cond == NotEqual);
  Condition actual = (  UseScratchRegisterScope temps(this;
  , ImmTagSignExt(JSVAL_TAG_MAX_DOUBLE,label,actual);
}

void MacroAssembler::  load32(Address(scratch2BigInt:offsetOfDigitLength() )java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
                                     *) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1
  splitSignExtTag(alue scratch2)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  branchTestDouble(cond, scratch2, label);
}

void MacroAssembler::branchTestDouble(Condition cond, const Address& address,
                                      ) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  Register tag = void MacroAssembler::branch(Conditioncond,
  branchTestDouble(cond, tag, label);
}

void MacroAssembler::branchTestDouble(Condition cond, const BaseIndex& address,
                                      Label*label) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  Register tag = extractTag(address, scratch2);
  branchTestDouble(cond, tag, label)  UseScratchRegisterScope temps();
}

void valuejava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 35
                                            void MacroAssembler::branchTestBoolean(Condition &address,
  ScratchDoubleScope fpscratch(*this);
  loadConstantDouble(0.0,fpscratch);
  DoubleCondition cond = b ? DoubleNotEqual : DoubleEqualOrUnordered;
  branchDouble     ( ;
}
voidjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                      )java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  branchTestGCThingImpl  UseScratchRegisterScopejava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 38
}

void branchTestBoolean,tag label;
                                       Label* label) {
branchTestGCThingImplc l)
}

void UseScratchRegisterScopethisjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                                       java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
Label{
  branchTestGCThingImpl(cond, address, label);
}
void MacroAssemblerLabellabel java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                                    *label) java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
);
  ma_b(tag, ImmTagSignExt(JSVAL_TAG_INT32), label, cond);
}

void MacroAssembler::java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
Label java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  tempsthisjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
psAcquire)
  Register =tempsAcquire)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  (cond  label)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
}

oid MacroAssembler:branchTestInt32(Condition cond, const Address& address,
                                     Label* label) {
  UseScratchRegisterScope temps(  UseScratchRegisterScope temps(this
Registerscratch2=temps.Acquire(;
  Register tag  egister tag =extractTag(address,scratch2);
  cond,tag, label)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}

void MacroAssembler::branchTestInt32(Condition cond, const BaseIndex& address,
                                     Label* label) {
  java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 38
  Register scratch2  cond,)
  Register tag = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [65, 36) out of bounds for length 36
}
void ScratchDoubleScope(this)
                                           java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 37
UseScratchRegisterScopetempsthis;
  Register scratch =   branchDouble(cond, value, fpscratch, label);
  SignExtendWord(scratchjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 Zero);
}
java.lang.StringIndexOutOfBoundsException: Range [51, 4) out of bounds for length 66
                                     Label* label) {
MOZ_ASSERT(ond=Equal|  =NotEqual;
  ma_b(tag, ImmTagSignExt(JSVAL_TAG_MAGIC
}

void(Conditioncond,const Address&address,
                                     Label* label) {
UseScratchRegisterScope(his);
  Register scratch2 = temps.Acquire();
   tag  extractTagaddress,scratch2)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   MacroAssembler(ondition cond,
}

voidMacroAssembler::branchTestMagic(Condition cond,const BaseIndex&addressjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
                                                                            * label {
  UseScratchRegisterScope temps(this);
  Register scratch2void MacroAssembler:(Condition ,Register tag,
  Register tag = extractTag(address, scratch2);
  branchTestMagic(cond, tag, label);
}

void MacroAssembler:branchTestMagic( cond,const ValueOperand&value
                                     Label* java.lang.StringIndexOutOfBoundsException: Range [0, 49) out of bounds for length 1
  UseScratchRegisterScope temps();
  Register scratch2 =                            * label) java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  splitSignExtTag(value, scratch2);
  (ond,,label)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
}

void ::ranchTestMagic(Conditioncond,const Address&valaddr,
                                     JSWhyMagic why, Label* label) {
   magic =MagicValue(hy.()java.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
  UseScratchRegisterScope temps(this);
 Register scratch =tempsAcquire(;
  loadPtr(valaddr, scratch);
  ma_b(scratch, ImmWord(magic), label, cond);
}

void    ;
                                     JSWhyMagic why, Label* label) {
     MagicValuewhy.asRawBits()java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
UseScratchRegisterScopetemps()
Registerscratch=temps.cquire);
  loadPtr(valaddr, scratch);
  ma_b(scratch, ImmWord(magic), label, cond);
}
void MacroAssembler::branchTestNull(Condition cond, Register tag,
                   Label label){
  MOZ_ASSERT(cond ==  Register tag =extractTag(address,scratch2);
  ma_b(tag, ImmTagSignExt(JSVAL_TAG_NULL), label, cond);
java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 1

                                           )
Label  
  UseScratchRegisterScope temps(this);
.Acquire)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  (value,scratch2)
  branchTestNull
}

voidLabel* label){
                                    Label* label) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps  MOZ_ASSERTcond=Equal |  = NotEqual);
   tag  extractTagaddress,scratch2)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  branchTestNull(cond, void MacroAssembler:branchTestMagic(Conditioncond const & address,
}

void MacroAssembler t)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      Label java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
   (  ;
  Register scratch2 = temps.Acquire();
  Register tag = extractTag(address :Conditioncond   ,
              ){
}
:( cond tag,
                                      Label* label) {
  MOZ_ASSERT(cond == Equal || cond == NotEqual);
  Condition actual = cond == Equal ? BelowOrEqual :  tag=extractTaga,scratch2)
  ma_b(  c,tag,label);
}

void MacroAssembler
                                      Label )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  UseScratchRegisterScopetemps()java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  Register scratch2 = temps.Acquire(  (alue ;
  v,scratch2)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  branchTestNumber(voidMacroAssembler:(ondition cond,  Address&valaddrjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
}
void MacroAssembler::uint64_t magic = MagicValue(why).asRawBits();
                                      Label* label) {
  MOZ_ASSERT  =.(;
  loadPtr,)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
}

void MacroAssemblervoid :Conditioncond  &valaddrjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
                                      Label* label) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  );
  branchTestObject(  Register scratch =temps.Acquire();
}

void MacroAssembler:branchTestObject(Condition cond, const Address& address,
                                      Label* label) {
this;
Register  tempsAcquire)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 branchTestObjectcond,tag,)
}

java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 38
                  * {
  UseScratchRegisterScope(, ;
   scratch2=temps.);
  Register java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
branchTestObjectcond,tag label;
}
void MacroAssembler::branchTestPrimitive(Condition cond,
   constValueOperand&valuejava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
                                         Label* label) {  scratch2=temps.cquire)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  UseScratchRegisterScope java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  Register scratch2 = Label java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
(valuescratch2)
branchTestPrimitivecond scratch2, labeljava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
void:Condition, &value,
                                                                               Label* l
  MOZ_ASSERT(cond;
ma_btag JS:java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 73
       (cond == Equal)  Label*)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
}
 MacroAssembler:cond  java.lang.StringIndexOutOfBoundsException: Range [78, 77) out of bounds for length 78
) java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  Label)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
             =NotSigned
  ifscratch2 .(;
    ma_b(lhs, rhs, label, cond);
  } else {
     temps()
ch=tempsAcquire(;
    and_(scratch, lhs, rhs);
    ma_b(scratch, java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
  }
}

void MacroAssembler    extractTagaddress,scratch2;
                                   Label* label) {
  MOZ_ASSERT(cond }
             cond == NotSigned);
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
Registerscratch=temps.)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  UseScratchRegisterScopejava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  scratch  label, cond);
}

void  java.lang.StringIndexOutOfBoundsException: Range [24, 18) out of bounds for length 37
                                   Label*                                         c  valuejava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  MOZ_ASSERT java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 38
             = NotSignedjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  UseScratchRegisterScope temps(this);
  Register scratch = temps.Acquire();
  ma_and(scratch, lhsvoid MacroAssembler:branchTestPrimitiveConditioncond, Register ,
  ma_b(scratch, scratch, label, cond);
}

void MacroAssembler::branchTestPtr(Condition cond, const Address& lhs,
                                   rhs, *label){
    ma_b(, ImmTagSignExt(S::ValueUpperExclPrimitiveTag,label,
  Register scratch2 = temps.Acquire() =)?  :AboveOrEqual
  loadPtr(MacroAssembler:(condlhs rhs
  branchTestPtr(                    *label java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
}
voidMacroAssembler:(Conditioncond, Register,
  if lhs= rhs){
  MOZ_ASSERT(cond == Equal || cond == NotEqual);
 ImmTagSignExt(JSVAL_TAG_STRING,label,cond)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
}

   Registerscratch =temps.(;
                                      Label* label) {
 UseScratchRegisterScopetemps(his;
  Register scratch2 = temps.Acquire    (,java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 40
  void MacroAssemblerCondition, lhs Imm32
                      
}

void cond=NotSigned;
                                      Label* label) {
  UseScratchRegisterScope    A)
  Registerma_andscratchlhs ;
  Register tag = extractTag(address, scratch2);
  branchTestString(cond, tag, java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 1
}

void MacroAssembler::branchTestString(Condition                                    *label){
                                      Label | cond ==Signed ||
  UseScratchRegisterScope temps              = )java.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
    java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 28
Register =extractTagaddress scratch2;
  branchTestString
}
voidMacroAssembler:branchTestStringTruthy(bool b, const ValueOperand& value,
                                            Label* label) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  unboxStringUseScratchRegisterScopetempsthis;
  load32(Address(  Registerscratch2  Acquire)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
,Imm32(), java.lang.StringIndexOutOfBoundsException: Range [56, 32) out of bounds for length 56
}
void           Labeljava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                                      Label* label) {
 cond = Equal| cond= NotEqual)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  ma_b(tagjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void MacroAssembler::                               *label) {
   Label* {
  UseScratchRegisterScope temps( scratch2 Acquire)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  Register scratch2 = temps.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  splitSignExtTag(value, scratch2);
  branchTestSymbol(cond, scratch2, label);
}

void MacroAssembler::branchTestSymbol  UseScratchRegisterScope temps(his)
Label*label){
UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  Register ag= extractTag(ddress, scratch2;
  branchTestSymbol
}

 MacroAssembler:branchTestSymbol(Condition cond, const Address& address,
                                      Label* Label label java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
Register=extractTagaddress,scratch2;
Register=Acquire)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  Register tag = extractTagvoid ::ranchTestStringTruthy(bool b, const ValueOperand& value,
               Label label){
}
voided(Conditioncond,
                                         const ValueOperand& value,
                                         Label* label) {
  UseScratchRegisterScopetemps(this);
  Register scratch2 =   load32(Address(cratch2, JSString::offsetOfLength()), scratch2);
  ma_b(scratch2 Imm32(0) label,b?NotEqual :Equal)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  branchTestUndefined(ond scratch2, label);
}

 MacroAssembler::branchTestUndefined(Condition cond, const Address& address,
                                         Label* label) {
  UseScratchRegisterScope temps(this);
  Registerscratch2 = temps.cquire)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  Register tag java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   label);
}

void MacroAssembler::  UseScratchRegisterScope temps(this temps(his)
                                                                              const BaseIndex address,
           Label label){
  UseScratchRegisterScope temps(this);
  branchTestSymbol,scratch2,label);
  Register tag = extractTag(address, scratch2
  void:(Conditioncond,constBaseIndex ddressjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
}
void MacroAssembler::branchTestUndefined(Condition cond, Register tag,
Label label)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  MOZ_ASSERT(cond ==  Register = Acquire)
ma_b(tag, ImmTagSignExtJSVAL_TAG_UNDEFINED  )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
}
 java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 21
 :branchTestValueConditioncond,constT java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                                     const ValueOperand& rhs, Label* label) {
    ranchTestSymbolcond ,)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 branchPtrcond lhs,rhs.() label;
}
void MacroAssembler::branchToComputedAddress(const BaseIndex& addr) {
  UseScratchRegisterScope temps(this);
  Register                                       ValueOperand valuejava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  (addr, scratch2)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  branch(scratch2);
}
void MacroAssembler  branchTestUndefinedcond scratch2 label)
                                                        Register dest,
                                                        *fail {
 exactly this conversion.
  if (HasZfaExtension()) {
    fcvtmod_w_d(java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 38
    ;
  }

  UseScratchRegisterScopecond,tag label;

  // Convert scalar to signed 64-bit fixed-point, rounding toward zero.
/  caseoverflow or NaN, the output is saturated.
  // In the case of -0, the output is zero.
  (,src;

  // Zero if NaN, so we don't take the failure path below.Labellabel){
  UseScratchRegisterScopet(this;

  // Unsigned subtraction of INT64_MAX returns 1 resp. 0 for INT64_{MIN,MAX}.
  Register scratch = temps.Acquire();
  scratch (x7fffffff'');
  sub(scratch,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  // Fail if the result is saturated.
branchPtrAssembler:,() ;

  // Clear upper 32 bits.
move32SignExtendToPtr(dest, dest);
}

voidMacroAssembler:branchTruncateDoubleToInt32FloatRegister src,
                                                 Register dest, Label* fail) {
//java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71

  // In the case of -0, the output is zero.
 ,)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

  // Zero if NaN, so we don't take the failure path below.
  Clear_if_nan_d(dest, src);

//Signextendlower bits to test ifresult isn'anInt32.
  {
    UseScratchRegisterScope temps(this)loadPtraddr, java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
MacroAssembler:branchTruncateDoubleMaybeModUint32(FloatRegister src,

    move32SignExtendToPtrdest,scratch);
    branchPtr(Assembler::NotEqual, dest, scratch, fail);
  }
}
void MacroAssembler::branchTruncateFloat32MaybeModUint32(FloatRegister src,
                                                         Register dest,
                                                         Label* fail) {
  // Infallible operation on riscv64.
  truncateFloat32ModUint32(src,  UseScratchRegisterScopetemps(this)
}

void MacroAssembler::branchTruncateFloat32ToInt32(FloatRegister src,
                                                  Register dest, Label* fail) {
  // Convert scalar to signed 64-bit fixed-point, rounding toward zero.
  // In the case of overflow or NaN, the output is saturated.(dest java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  // In the case of -0, the output is zero.
  Trunc_l_s(dest, src);

  // Zero if NaN, so we don't take the failure path below.
 Clear_if_nan_sdest )

 // Sign extend lower 32 bits to test if the result isn't an Int32.
  {
    UseScratchRegisterScope temps(this);
    Register scratch = temps.Acquire();

    move32SignExtendToPtr(dest, scratch);
    branchPtr(Assembler::NotEqual, dest, scratch, fail);
  }
}

MacroAssemblerbranchInt64NotInPtrRangejava.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 77
  // No-op on 64-bit platforms.
}

void MacroAssembleror,the outputis saturatedjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  branchTest64(Assembler::Signed, src  Trunc_l_ddest src;
}

void MacroAssembler::byteSwap16SignExtend(  Clear_if_nan_d(dest,src)
  ByteSwap(src, src, 2);
}

void MacroAssembler::byteSwap16ZeroExtend(Register src)     UseScratchRegisterScope(his;
  ByteSwap(src, src, 2, /* zeroExtend= */ true); tempsAcquire;
}

void MacroAssembler::byteSwap32(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 3

void java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  ByteSwap(src.reg, src.reg, 8);
}

MacroAssembler:java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 52
  ,then to  0
  {
 tempsthis;
    Register scratch = temps.Acquire();

    // reg = -(reg > 0 ? 1 : 0) & reg
    sgtz(scratch, reg);
    neg( ;
    and_(reg, reg, scratch);
  }

  // If reg is >= 255, then we want to clamp to 255.
  Label skip;
  ma_b(reg, Imm32(255), &skip, java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 3
  {
    ma_li(eg,Imm32())
  }
  bind(&skip);
}

java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 1
(, src)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
}
void MacroAssemblerjava.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
Clz64,.reg;
}

void MacroAssembler::ctz64(Register64 src, Register64 dest) {
 Ctz64dest.eg, srcreg);
}

void MacroAssembler::cmp16Set(Condition cond, Address lhs, Imm32  ByteSwap(, src,2);
                              Register dest) {
  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
 Register scratch2  .(;
  MOZ_ASSERT(scratch2 != lhs.base);

  switch (cond) {
    case Assembler::Equal:
    case Assembler::NotEqual:
    case Assembler::Above:
     Assembler:AboveOrEqual:
    case Assembler::Below:
    case Assembler::BelowOrEqual:
      load16ZeroExtend(lhs, scratch2);
      ma_cmp_set( :clampIntToUint8Register reg java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
      break;

    case Assembler::GreaterThan:
    case Assembler::GreaterThanOrEqual:
    case Assembler::    // reg = -(reg > 0 ? 0  reg
   case Assembler:LessThanOrEqual:
      (hs,scratch2;
ma_cmp_setdest scratch2,Imm32(int16_t(rhs.value)), cond);
      break;

    default:
      MOZ_CRASH("  / If reg is >= 255, then we want to clamp to 255.
  }
}

void MacroAssembler:  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
                                 const Address& rhs, java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 3
                                 Register dest
  UseScratchRegisterScope temps(this);
  Register scratch = temps.Acquire();
java.lang.StringIndexOutOfBoundsException: Range [12, 2) out of bounds for length 48
  load32(rhs, scratch);
  (cond,,scratch ,dest;
}

void MacroAssembler::cmp32Load32(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                 const Address& srcjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  Label skip;
h32Assembler:InvertConditionc,lhs ,&skip;
  load32(src, dest);
  bind(&java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1
}

void MacroAssembler::cmp32Load32(Condition  UseScratchRegisterScope(this;
        constAddress&src, ){
  Label skip;
  OZ_ASSERTscratch2! lhs.base);
  load32(
bind&kip;
}    Assembler::

voidMacroAssembler:( ,const Address&lhs,Imm32 ,
      load16ZeroExtend,;
  Label skip;
  branch32(Assembler break
  loadPtr(src, dest);
  bind(&skip);
}

dition     
                                 Registerl, ;
  (, lhs   ;
}

void java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 12
                                 Register src, java.lang.StringIndexOutOfBoundsException: Range [0, 55) out of bounds for length 1
  (, rhs  ;
}

void MacroAssembler::cmp32Move32(Condition cond, Register lhs,
                                 const Address& rhs, Register src,   tempsthis)
                                 Register dest) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  MOZ_ASSERT(lhs != scratch2 && src != scratch2 && dest != scratch2);
tch2;
  cmp32Move32(cond, lhs, scratch2, src, dest);
}
void MacroAssembler::cmp32MovePtrvoid MacroAssembler:cmp32Load32C cond,Register   rhs
                                    ){
  dest, ,src cond)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
}
void   load32(src,dest);
                              Register dest) {
  ma_cmp_set(dest, lhs.reg, rhs.reg, cond);
}
void MacroAssembler::cmp64Set(Condition 
                              void MacroAssembler::cmp32Load32(Condition lhs, Imm32 rhs,
  ma_cmp_set(dest, lhs.reg,                                const &src,  ){
}
 :Conditioncond,   rhs,
                              Register dest
  ma_cmp_set(dest, lhs, rhs.reg, cond
}
void MacroAssembler::void MacroAssembler::cmp32LoadPtrCondition , const Address&lhs Imm32 rhs,
                              Register dest) {
  ma_cmp_set(dest, lhs, ImmWord(uint64_t(rhs.value)), cond);
}
void MacroAssembler::cmp8Set(Condition cond, Address lhs, Imm32 rhs,
                              dest) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire() Assembler:()  ,&;
  MOZ_ASSERT(scratch2 != lhs.base);

  switch (cond) {
    case Assembler
::NotEqual
    case Assembler::                                  , java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    case Assembler::AboveOrEqual:
    case Assembler:Below:
    case                  java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 63
      load8ZeroExtend(lhs, scratch2);
      ma_cmp_set(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      break;

          Register java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    case   Register scratch java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 38
    :
    case Assemblert oad32rhs scratch2;
     load8SignExtend(hs )java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  ma_cmp_set(,scratch2,Imm32(int8_t(hs.valuecond;
      break;

    default:
      MOZ_CRASH("unexpected condition");
  }
}
void MacroAssembler::cmpPtrMovePtr(Condition cond, Register lhs, Register rhs,
                                   Register src, Register dest) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquirev :(Condition,Register64lhs,Imm64,
  cmpPtrSet(cond, lhs, rhs, scratch2);
  moveIfNotZero                              Register dest {
}

void java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
                                   Register src
  MOZ_CRASH");
}

 :(Condition cond,Register lhs,
                                   const Address& rhs,                             Register ){
                                   Register dest) {
  (NYI)
}

java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 76
  Ctz32java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 38
}

void MacroAssembler::decBranchPtr    Assembler::
                                  Label* label) {
  subPtr(rhs, lhs);
  branchPtr(cond, lhs, Imm32(0), label);
}
:divFloat32FloatRegistersrc FloatRegister dest) {
  fdiv_s(dest, dest, src);
}

java.lang.StringIndexOutOfBoundsException: Range [44, 4) out of bounds for length 71
  fdiv_d(dest, dest, src)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
void MacroAssembler::fallibleUnboxPtr(const ValueOperand ::
                                      JSValueType type, Label* fail) {
  MOZ_ASSERT(type == JSVAL_TYPE_OBJECT ||       dest,,Imm32int8_trhsv) )java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
             type == JSVAL_TYPE_SYMBOL || type == JSVAL_TYPE_BIGINT);
/java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  // scratch := dest >> JSVAL_TAG_SHIFT
  // fail if scratch != 0
  //
  // Note: src and dest can be the same register
  UseScratchRegisterScope temps(this);
  Register scratch = temps.Acquire();
  MOZ_ASSERT(src.valueReg() != scratch);
  mov(ImmShiftedTag(type), scratch);
  java.lang.StringIndexOutOfBoundsException: Range [25, 6) out of bounds for length 38
srli( dest, JSVAL_TAG_SHIFT);
  ma_b(scratch, Imm32(  (,rhs;
}

void MacroAssembler::fallibleUnboxPtr}
                                      JSValueType type, Label* fail) {
(src)
  fallibleUnboxPtr(ValueOperand(dest),                                    RegisterRegister java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
}

void MacroAssembler::fallibleUnboxPtr(const BaseIndex& src, Register est
                                      JSValueType type                                    Address rhs,Registersrc,
  loadValue(               Registerdest) java.lang.StringIndexOutOfBoundsException: Range [51, 52) out of bounds for length 51
  fallibleUnboxPtr(ValueOperand(dest), dest, typevoid MacroAssembler:ctz32( src Register dest,bool ) java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
}
void java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  (src,;
}
void MacroAssembler::flexibleRshift32Arithmetic(Register src, Register dest) {
  rshift32Arithmetic(src, dest);
}
 MacroAssembler::lexibleRshift32R src Register ){
  rshift32(src, dest);
}
ler:(AbsoluteAddressdest){
  UseScratchRegisterScope
   scratch =.)
  Register scratch2 = temps(, 
  ma_li(scratch, ImmWord(uintptr_t(java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 0
  ld(scratch2, scratch, 0);
  addi(scratch2, scratch2, 1);
  sd(scratch2 :( &src  java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
}

 Address& src,Register java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  s,dest;
}
void MacroAssembler::loadAbiReturnAddress(  / scratch : dest >> JSVAL_TAG_SHIFT

void MacroAssembler::lshift32(Register src, Register dest) {
  sllw(dest, dest, src);
}

void MacroAssembler:: UseScratchRegisterScope temps(this)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  lshift32(imm, dest, dest);
}

void MacroAssembler::lshift32( mov((type),scratch;
(,src,imm. & 01)
}

void MacroAssembler::lshift64 ma_bscratch,Imm32(),fail :NotEqual)
  sll(dest.reg, dest.reg, shift
}

void:I,Register64) java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  MOZ_ASSERT( <imm.value &imm. <64;
  slli(dest.reg, dest.reg, imm.value);
}
void MacroAssembler::lshiftPtr(Register  (ValueOperand() dest, type,fail;
  sll(dest, dest, shift);
}

 MacroAssembler:lshiftPtr(Imm32imm,Register dest {
  lshiftPtr(imm, dest, dest);
}

void MacroAssembler::lshiftPtr(Imm32   ValueOperanddest,,type ;
  MOZ_ASSERT(0 <= imm.value }
  slli(dest, src, void :(java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 68
}

void MacroAssembler:v MacroAssembler:flexibleRshift32ArithmeticRegister src, Register dest) {
  lshiftPtr(shift, srcDest);
}

void MacroAssembler::min32(Register lhs, void MacroAssembler::flexibleRshift32(Register sr dest) {
  (,rhs, dest, /* isMax = */ false);
}

voidMacroAssembler:min32Register ,Imm32 rhs,Register dest java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  minMax32(lhs, rhs,   Register scratch = temps(;
}

void MacroAssembler::max32(Register lhs, Register rhs, Register dest)  ma_li(,ImmWord((dest.ddr))
  minMax32(lhs, rhs, dest, /* isMax = */ true);
}

void java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [37, 2) out of bounds for length 47
}

voidjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  minMaxPtr(lhs, rhs, dest, /* isMax = */ false);MOZ_ASSERT(0<=immvalue&& imm.value <64)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
}void MacroAssembler:lshiftPtr(Register shift,Register dest) {

void MacroAssembler::minPtr(Register lhs, ImmWord java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 25
  minMaxPtr(
}

void MacroAssembler::maxPtr(Register lhs, java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 1
  minMaxPtr(lhs, rhs, dest, /* isMax = */ true);
}

(Registerlhs ImmWord rhs,Register dest){
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
}

void MacroAssembler::maxDouble(FloatRegister other, FloatRegister srcDest,
                               booljava.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 1
r);
}
void   minMax32(lhs,,dest /* isMax = */ false);
                                bool handleNaN
s  )
}
void MacroAssembler::memoryBarrier(MemoryBarrier barrier) {
   (barrier..isNone(){
    ync)
  }
}
voidMacroAssembler::minDouble(loatRegister other, FloatRegister srcDest,
                               bool handleNaN) {
Float64Min(srcDest,srcDest,other);
}
void MacroAssemblerjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                bool handleNaN) {
  Float32Min(srcDest, srcDest, other);

void MacroAssembler::move16SignExtend(Register src, Registerjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  SignExtendShort(dest, src);
}
void MacroAssemblerjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 (dest.reg.reg,src)
}
void MacroAssembler::move8SignExtendToPtr(Register src}
  move8To64SignExtend(src, Register64(dest));
}
void MacroAssembler::ove16SignExtendToPtr(Register src, Register dest) {
  move16To64SignExtend(src, Register64(dest));
}
 MacroAssembler:(Register src, Register dest) {
  SignExtendWord(  (,srcDest )java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
}
void MacroAssembler::move32To64SignExtend(Register src, Register64 dest) {
  SignExtendWord(dest.reg, src);
}
MacroAssembler:( ,  dest 
  ZeroExtendWord(dest.reg, src);
}
void MacroAssembler::move32ZeroExtendToPtr(Register src, Register dest) {
  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
}
void MacroAssembler::move64(Register64 src, Register64 dest)  java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 38
  movePtr(src.reg, dest.reg);
}

Float32MinsrcDest srcDest, other)
  movePtr(ImmWord(imm}
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void MacroAssembler::void:move16To64SignExtendjava.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 74
  SignExtendWord(est,src.reg);
}

void MacroAssembler::move8ZeroExtendjava.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
  andi(dest, src, 0xFF);
}

void MacroAssembler::move8SignExtend(Register srcjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  SignExtendByte(dest, src);
}
void MacroAssembler::move8To64SignExtendMacroAssembler:( java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 73
  SignExtendByte(dest.reg, src);
}
void MacroAssembler::moveDoubleToGPR64(FloatRegister  (.eg,)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  (.reg ;
}

voidjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  fmv_d_x(dest, src.reg);
}
void MacroAssembler::moveLowDoubleToGPR(FloatRegister src, Register dest) {
  MOZ_CRASH("Not supported for thisvoidMacroAssembler::move64(Register64 src, Register64 dest) {
}
void MacroAssembler::moveFloat32ToGPR(FloatRegister src, Register destjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  fmv_x_w(dest, src);
}
void MacroAssembler:( ,  ){
  fmv_w_x(dest, src);
}
void MacroAssembler::moveFloat16ToGPR(FloatRegister src, Register dest)}
  MOZ_ASSERT(HasZfhminExtension());
  fmv_x_h(
}
void MacroAssembler::moveGPRToFloat16(Register   (,src.;
  MOZ_ASSERT(HasZfhminExtension());
  fmv_h_x(void:move8ZeroExtendsrc  )java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
}
void MacroAssembler::mul32
  mulw(srcDest, srcDest, rhsvoid MacroAssembler::move8SignExtend(Register src, Register dest) {
}

void MacroAssembler::mul32(java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 1
  ma_mul32(srcDest , )java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
}

void MacroAssembler::mulHighUnsigned32(Imm32 imm, Register src, Register dest) {
void :( , dest)java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
}

void MacroAssembler::mul64(  dest .)
  ma_mul64(dest.reg, dest.reg, imm);
}

void MacroAssembler::mul64  (Notsupportedforthistarget";
                           voidMacroAssembler:(FloatRegistersrc  dest){
  MOZ_ASSERT(temp == Register::Invalid(, ;
( ;
}

voidMacroAssembler:mul64(const Register64& src, const Register64& dest,
                           const Register temp) {
  MOZ_ASSERT(temp == Register::Invalid());
  mul(dest.reg, dest.reg, src.reg) MOZ_ASSERT(())
}

void MacroAssembler::mulBy3(RegistervoidMacroAssembler::moveGPRToFloat16(Register src, FloatRegister dest) {
  UseScratchRegisterScope temps(this);
  Register scratch = temps.Acquire();
  MOZ_ASSERT(src != scratch);
  add(scratch, src MacroAssembler:(Registerrhs RegistersrcDest java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  add(dest, scratch, src);
}
void MacroAssembler::mulDouble(FloatRegister src, FloatRegister dest) {
  fmul_d(destjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}
void MacroAssembler::mulDoublePtr(ImmPtr imm, Register temp,
                                  FloatRegister dest) {
  UseScratchRegisterScope temps(this);
  Register scratch = temps.Acquire();
  ScratchDoubleScope fpscratch(asMasmjava.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
  movePtr(imm, scratch);
  loadDouble(Address(scratch, 0), fpscratch);
  mulDouble(fpscratch, dest);
}
java.lang.StringIndexOutOfBoundsException: Range [31, 19) out of bounds for length 72
  fmul_s(dest, dest, src);
}
void MacroAssembler::mul64(const Register64& rhs, const Register64& srcDest) {
  mul(srcDest.reg, srcDest.reg, rhs.reg);
}
void MacroAssembler::mulPtr(Register rhs, Register srcDest) {
  (,srcDest,rhs)
}
void MacroAssembler::mulPtr(ImmWord rhs, Register srcDest) {
  ma_mul64(srcDest, srcDest, rhs);
}

void MacroAssembler::negateDouble(FloatRegister reg) { fneg_d(reg, reg); }

void MacroAssembler::negateFloat(FloatRegister reg) { fneg_s(reg, reg); }

void MacroAssembler::neg64(Register64 regRegister=.(;

void MacroAssembler::negPtr(Register reg) { java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 25

void void MacroAssembler::mulDouble(FloatRegister src, FloatRegister dest) {
 :not32 reg){ (reg,reg;}

void MacroAssemblervoid MacroAssembler:mulDoublePtr(mmPtr imm,Register ,

void ::r32R src, dest  (dest,dest,) java.lang.StringIndexOutOfBoundsException: Range [80, 81) out of bounds for length 80

void MacroAssembler::or32(Imm32 imm, Register dest) { ma_or(dest, dest, imm); }

java.lang.StringIndexOutOfBoundsException: Range [19, 4) out of bounds for length 67
  ma_or(dest, immjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
}

void   mulDouble,dest);
  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1
  Register scratch2 = temps.Acquire();
  load32(dest, scratch2);
  ma_or(scratch2, scratch2, imm);
  store32(scratch2, void MacroAssembler::mul64 &rhs  Register64 ){
}

void MacroAssembler::java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
  or_(dest.reg, dest.reg, src
}

 o(,java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 55
  ma_or(dest.reg, dest.reg, imm);
}

void MacroAssembler::orPtr(Register src, Register dest) {
  or_ MacroAssembler:neg64Register64) { neg(reg., reg.eg;}
}

 MacroAssembler:orPtr(Imm32 imm, Register dest) { ma_ordest, dest, imm); }

void MacroAssembler::orPtr(Imm32 imm, Register src, Register dest) {
  ma_ordest,src,imm)
}

void MacroAssembler::popcnt32(Register input, Register output, Register tmp) void:() java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 61
  Popcnt32(output, input, void MacroAssembler::or32(Imm, {(est, ,imm;}
}
java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 66
Register
  Popcnt64(output.reg, input.reg, tmp);
}
void MacroAssembler::quotient32(Register lhs, Register rhs, Register dest,
                        isUnsigned java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  if (isUnsigned) {
    divuw(dest, lhs, rhs);
}else {
    divw
  }
}

void MacroAssemblerdest,;
                                java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
  i){
    divu(dest, lhs, rhs);
  } else {
    div(dest, lhs, rhs);
  }
}

void MacroAssembler::}
                                 bool isUnsigned) {
  if (isUnsigned) {
    remuw(dest, lhs, rhs);
  } else {
    remw(dest, lhs, rhs);
  }
}

void :rotateLeft64(Register count,Register64 src,
                                 bool isUnsigned) {
  if (isUnsigned) {
    remu(dest, lhs, rhs);
  } else {
    rem(dest, lhs, rhs);
  }
}

void MacroAssembler::rotateLeft64(Imm32 count, Register64 src, Register64 dest,
                                  Register temp) {
  Drol(dest.reg, src.reg, count);
}
void MacroAssembler::rotateLeft64(Register count, Register64 src,
                                  Register64 dest, Register temp) {
  Drol(dest.reg, src.reg, count);
}

void MacroAssembler::rotateLeft(Imm32 count, Register input, Register dest) {
  Rol(dest, input, count);
}
void MacroAssembler::rotateLeft(Register count, Register input, Register dest) {
  Rol(dest, input, count);
}

void MacroAssembler::rotateRight64(Imm32 count, Register64 src, Register64 dest,
                                   Register temp) {
  Dror(dest.reg, src.reg, count);
}
void MacroAssembler::rotateRight64(Register count, Register64 src,
                                   Register64 dest, Register temp) {
  Dror(dest.reg, src.reg, count);
}

void MacroAssembler::rotateRight(Imm32 count, Register input, Register dest) {
  Ror(dest, input, count);
}
void MacroAssembler::rotateRight(Register count, Register input,
                                 Register dest) {
  Ror(dest, input, count);
}

void MacroAssembler::rshift32Arithmetic(Register src, Register dest) {
  sraw(dest, dest, src);
}

void MacroAssembler::rshift32Arithmetic(Imm32 imm, Register dest) {
  rshift32Arithmetic(imm, dest, dest);
}

void MacroAssembler::rshift32Arithmetic(Imm32 imm, Register src,
                                        Register dest) {
  sraiw(dest, src, imm.value & 0x1f);
}

void MacroAssembler::rshift32(Register src, Register dest) {
  srlw(dest, dest, src);
}

void MacroAssembler::rshift32(Imm32 imm, Register dest) {
  rshift32(imm, dest, dest);
}

void MacroAssembler::rshift32(Imm32 imm, Register src, Register dest) {
  srliw(dest, src, imm.value & 0x1f);
}

void MacroAssembler::rshift64Arithmetic(Imm32 imm, Register64 dest) {
  MOZ_ASSERT(0 <= imm.value && imm.value < 64);
  srai(dest.reg, dest.reg, imm.value);
}

void MacroAssembler::rshift64Arithmetic(Register shift, Register64 dest) {
  sra(dest.reg, dest.reg, shift);
}

void MacroAssembler::rshift64(Register shift, Register64 dest) {
  srl(dest.reg, dest.reg, shift);
}

void MacroAssembler::rshift64(Imm32 imm, Register64 dest) {
  MOZ_ASSERT(0 <= imm.value && imm.value < 64);
  srli(dest.reg, dest.reg, imm.value);
}

void MacroAssembler::rshiftPtrArithmetic(Imm32 imm, Register dest) {
  rshiftPtrArithmetic(imm, dest, dest);
}

void MacroAssembler::rshiftPtrArithmetic(Imm32 imm, Register src,
                                         Register dest) {
  MOZ_ASSERT(0 <= imm.value && imm.value < 64);
  srai(dest, src, imm.value);
}

void MacroAssembler::rshiftPtrArithmetic(Register shift, Register dest) {
  sra(dest, dest, shift);
}

void MacroAssembler::flexibleRshiftPtrArithmetic(Register shift,
                                                 Register srcDest) {
  rshiftPtrArithmetic(shift, srcDest);
}

void MacroAssembler::rshiftPtr(Register shift, Register dest) {
  srl(dest, dest, shift);
}

void MacroAssembler::rshiftPtr(Imm32 imm, Register dest) {
  rshiftPtr(imm, dest, dest);
}

void MacroAssembler::rshiftPtr(Imm32 imm, Register src, Register dest) {
  MOZ_ASSERT(0 <= imm.value && imm.value < 64);
  srli(dest, src, imm.value);
}

void MacroAssembler::flexibleRshiftPtr(Register shift, Register srcDest) {
  rshiftPtr(shift, srcDest);
}

void MacroAssembler::spectreBoundsCheck32(Register index, Register length,
                                          Register maybeScratch,
                                          Label* failure) {
  MOZ_RELEASE_ASSERT(!JitOptions.spectreIndexMasking);
  branch32(Assembler::BelowOrEqual, length, index, failure);
}

void MacroAssembler::spectreBoundsCheck32(Register index, const Address& length,
                                          Register maybeScratch,
                                          Label* failure) {
  MOZ_RELEASE_ASSERT(!JitOptions.spectreIndexMasking);
  branch32(Assembler::BelowOrEqual, length, index, failure);
}
void MacroAssembler::spectreBoundsCheckPtr(Register index, Register length,
                                           Register maybeScratch,
                                           Label* failure) {
  MOZ_RELEASE_ASSERT(!JitOptions.spectreIndexMasking);
  branchPtr(Assembler::BelowOrEqual, length, index, failure);
}

void MacroAssembler::spectreBoundsCheckPtr(Register index,
                                           const Address& length,
                                           Register maybeScratch,
                                           Label* failure) {
  MOZ_RELEASE_ASSERT(!JitOptions.spectreIndexMasking);
  branchPtr(Assembler::BelowOrEqual, length, index, failure);
}
void MacroAssembler::spectreMovePtr(Condition, Register, Register) {
  MOZ_CRASH("spectreMovePtr");
}
void MacroAssembler::spectreZeroRegister(Condition cond, Register scratch,
                                         Register dest) {
  MOZ_CRASH("spectreZeroRegister");
}
void MacroAssembler::sqrtDouble(FloatRegister src, FloatRegister dest) {
  fsqrt_d(dest, src);
}
void MacroAssembler::sqrtFloat32(FloatRegister src, FloatRegister dest) {
  fsqrt_s(dest, src);
}

FaultingCodeOffset MacroAssembler::storeFloat16(FloatRegister src,
                                                const Address& dest, Register) {
  return ma_storeFloat16(src, dest);
}
FaultingCodeOffset MacroAssembler::storeFloat16(FloatRegister src,
                                                const BaseIndex& dest,
                                                Register) {
  return ma_storeFloat16(src, dest);
}

FaultingCodeOffset MacroAssembler::storeFloat32(FloatRegister src,
                                                const Address& addr                                  Register64 dest Register temp) {
  return ma_storeFloat(src, addr);
}
FaultingCodeOffset MacroAssembler::storeFloat32(FloatRegister src,
                                                const&){
  return ma_storeFloat(src,   (dest,input,count)
}

FaultingCodeOffset MacroAssembler::storeDouble(FloatRegister src,
                                               void MacroAssembler::rotateLeft(Register count, Register dest 
  return ma_storeDouble(src, addr);
}
FaultingCodeOffset MacroAssembler:(FloatRegister srcjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                                               const BaseIndex& addr) {
  return ma_storeDouble(src, addr);
}

void MacroAssembler::sub32(Register src, Register dest) {
  subw(dest, dest, src);
}

void MacroAssembler::  Ror(dest, input, count
  ma_sub32(dest, dest, imm);
}

void MacroAssembler::sub32(const Address& src, Register dest) {
  UseScratchRegisterScope tempsthis);
  Register scratch = temps.Acquire();
  load32(src, scratch);
  subw(dest, dest, scratch);
}

void MacroAssembler::sub64(Register64 src, Register64 dest) {
  sub(dest.reg, dest.reg, src.reg);
}

void MacroAssembler::sub64(Imm64 imm, Register64 dest) {
  ma_sub64(dest.reg, dest.reg, imm);
}

void MacroAssembler::subDouble(FloatRegister src, FloatRegister dest) {
  fsub_djava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void MacroAssembler::subFloat32(FloatRegister src, FloatRegister dest) {
  fsub_s(dest, dest, src);
}

void MacroAssembler::subPtr(Register src, const Address& dest) {
  UseScratchRegisterScope temps(this);
  Register scratch = temps.Acquire();
  loadPtr(dest, scratch);
  subPtr(src,   sraiw(dest, src, imm(dest,src,immvalue &0x1f)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
( ;
}

void
  UseScratchRegisterScope void MacroAssembler::rshift32imm,Register)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
vo :rshift32Imm32 ,  src, Register dest) {
( )
  subPtr(scratch, dest);
}
void MacroAssembler::subPtr(Imm32 imm, Register dest) {
ma_sub64(dest,dest,imm)
}
void MacroAssembler::subPtr(Register src, Register dest) {
  sub(dest, dest, src);
}
void MacroAssembler::test32LoadPtr(Condition cond,  sradest.reg, , shift)
                                   mask,const & srcjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                                   Register dest) {
  java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
  Label skip;
  branchTest32(Assembler:InvertCondition(ond,addr,mask s)
  loadPtr(src, dest);
bind&skip)
}
 MacroAssembler:(Condition   java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 71
                                   Imm32 mask, Register src, Register dest) {
  MOZ_ASSERT(cond == Assembler::Zero  (imm dest,dest)
  Label skip;
  branchTest32(Assembler::InvertCondition(cond), addr, mask, &skip);
  movePtr(src, dest);
  bind(&skip);
}
void MacroAssembler::java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                                   Register src, Register dest) {
MOZ_ASSERT(ond =Assembler::Zero|  =Assembler:)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  Label skip;
  ranchTest32(Assembler::InvertCondition(cond), operand, mask, &skip);
  movePtr(src, dest);
  bind(&skip);
}
void MacroAssembler::xor32(Register src, Register dest) {
  xor_(dest, dest, java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void MacroAssembler
 dest,dest, immjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
}

void MacroAssembler::xor32(Imm32 imm, Register src, Register dest) {
  ma_xor(dest, src, imm);
}

void MacroAssembler::xor32(Imm32 imm,
  (;
  Register scratch2 = Dest)
  load32(dest, scratch2);
  xor32void MacroAssembler:spectreBoundsCheck32Register ,Register length,
  store32(scratch2, dest);
}

void}
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.                               ,
  load32(src, scratch2);
  ,dest)
}
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  xor_(estreg .reg,src.eg)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}

void MacroAssembler::                          Label* failure) {
  ma_xor(dest.reg, dest.reg, imm);
}
void MacroAssembler::xorPtr(Register}
  xor_(dest, dest, src);
}

void MacroAssembler::xorPtr(Imm32 imm, Register dest) {
  ma_xor(dest, dest, imm);
}

void ::xorPtr( imm,   dest java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  ma_xor(dest, src, imm);
}

// ===============================================================
// 128-bit arithmetic

void MacroAssembler::wasmAddSubI128HI64(java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 1
                                        Register rhsLo, Register rhsHi,
                                        java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 35

  MOZ_RELEASE_ASSERT(java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 21
                     output:(   java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  // We use `output` as a temp to hold the carry or borrow.
  if (isAdd) {
    add(output, lhsLo, rhsLo);    // output = lhsLo + rhsLoconst    
o output,;/  =carry  l +`
    add(output, output, lhsHi);   // output = carry + lhsHi
, rhsHi) //
  } else {
    sltu(output, lhsLo, rhsLo);  // output = borrow from `lhsLo - rhsLo`
    sub(output, lhsHi, output);  // output = lhsHi - borrow
    sub(output, output, rhsHi);  // output = lhsHi - borrow - rhsHi
  }
}

 rhs,
                                        Register output,                                               const&){
  if (isSigned) {
    mulh(output, lhs, rhs);
  } else {
    mulhu(output, lhs, rhs);
  }
}

//}}} check_macroassembler_style

voidMacroAssemblerRiscv64Compat:incrementInt32Value(onstAddress ){
  asMasm().add32(Imm32(1), addr);
}

voidconst Address addr){
  // pc <- [sp]; sp += n
  java.lang.StringIndexOutOfBoundsException: Range [17, 9) out of bounds for length 40
  asMasm().addPtr(n, StackPointer);
  jr(ra, 0);
}
}  // namespace jit
}  // namespace js

#endif /* jit_riscv64_MacroAssembler_riscv64_inl_h */