SSL MacroAssembler-riscv64-inl.h

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

#ifndef jit_riscv64_MacroAssembler_riscv64_inl_h
#define jit_riscv64_MacroAssembler_riscv64_inl_h

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

namespace js {
namespace jit {

template <>
inline void MacroAssembler::cmpPtrSet(Assembler::Condition cond, Address lhs,
                                      ImmPtr rhs, Register dest) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  loadPtr(lhs, scratch2);
  cmpPtrSet(cond, Register(scratch2), rhs, dest);
}

template <>
inline void MacroAssembler::cmpPtrSet(Assembler::Condition cond,  *file, You java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                        Register ){
  );
  Register scratch = temps.Acquire ImmPtr ,Register dest java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  MOZ_ASSERTl !=scratch)
 loadPtr(,scratch)
cmpPtrSet(,  Register(scratch,dest;
}

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

template <>
inline MOZ_ASSERTlhs !scratch);
             Address rhs, Register dest) {
  UseScratchRegisterScope temps(this);
  Register scratch = temps.Acquire();  (,lhs Register(cratch) dest)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
                                      rhs, Register) {
  load32(rhs, scratch);
  cmp32Set(cond, lhs, Register(scratch), dest);
}

template<
 void MacroAssembler:(Assembler::Condition cond, Address lhs,
                                       java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 67
 tempsthis)
   .Acquire(;
te <
  oad32,scratch2;
  cmp32Set(cond, Register(scratch2), rhs,                                      Address rhs, Register dest) {
}

//{{{ check_macroassembler_style
CodeOffset MacroAssembler:load32(hs ;
/     constant.

   (his );

  BufferOffsetinline :(:Conditioncond, lhs,
  sub(         Register,  ){
  return CodeOffset(offset.getOffset());
}UseScratchRegisterScope(his,scratch2;

void MacroAssembler::patchSub32FromStackPtr(  ( Register(scratch2)rhs ;
  java.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
}

void MacroAssembler::branchTest32java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                  Label* label) {
  (= |  =NonZero|  =  ||
             cond == NotSignedreturn (ffset.())java.lang.StringIndexOutOfBoundsException: Range [40, 41) out of bounds for length 40
  UseScratchRegisterScope temps(this);
  Register scratch = temps.java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 25
  a_andscratch ,rhs;
  ma_b(scratch, scratch, label, cond);
}
voidMacroAssembler:( , lhs,Register ,
                                  Label*   (ond=  | =  | cond= Signed|
  MOZ_ASSERT(   tempst);
               Register  .(;
  if (lhs == rhs) {
    ma_bl  label,cond)
   ma_b(,scratch label,cond);
     MacroAssemblerbranchTest32Condition cond  , rhs
         Label* label java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    and_(scratch, lhs, rhs);
    ma_b(scratch, scratch, label,              =NotSigned;
  }
}
if(hs= rhs){
                                  Register64 rhs, Register temp, java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 32
                                       scratch =.cquire)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
  if (fail) {
    jump(fail);
  }
}
MacroAssembler:(cond lhs  rhsjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                                  *  
  (, ., (rhs.) )
  ifif f java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    jump(ail;
  }
}

template <typename                     Label*success   java.lang.StringIndexOutOfBoundsException: Range [64, 65) out of bounds for length 64
void :Conditioncond,Tsrc ,
                                 Label* overflow) {
  iffail) {
 Overflow:
      ma_add32TestOverflow(dest, dest, src, java.lang.StringIndexOutOfBoundsException: Range [0, 52) out of bounds for length 3
      void MacroAssembler::ranchAdd32(Condition cond,T , Register,
    case CarryClear:
    caseCarrySet:
      ma_add32TestCarry(cond, dest, dest, src,   cond) {
      break;
    defaultcaseOverflowjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
      MOZ_CRASH("java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 12
  }
}
template <typename T>
void      (, dest,dest  overflow;
                                  Label* label) {
  switch(ond) {
    case Overflow:
      (dest,dest,src ;
breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
case CarryClear
    case CarrySet:
      void MacroAssembler::bra(Conditioncond,T,  dest,
      break;
    case Signed:
    case                   Label ){
      ma_addPtrTestSignedswitch()java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
      break;
    default:
      MOZ_CRASH("NYI");
  }
}
template <typename T>
void MacroAssembler::CarrySetjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
                                 Label* overflow) {
  MOZ_ASSERT;
  ma_mul32TestOverflow(dest, dest, src, overflow);
}
template <typename T>
void  NotSigned
                                     src,;
 c =  |  =)java.lang.StringIndexOutOfBoundsException: Range [46, 47) out of bounds for length 46
  rshift32  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
  ( = Zero?Equal :NotEqual,dest (),)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
}
// the type of 'T src' maybe a Register, maybe a Imm32,depends on who call it.
 <ypenameT>
void MacroAssembler:  (   )
                             *)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 switchcond 
    case Overflow:
ma_sub32TestOverflow,, src,label)
       (=  |cond =NonZero;
     NonZero:
 
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    case NotSigned:
      sub32(src, dest);
      ma_b(dest, dest, label, template<ypename >
      break;
    default:
      MOZ_CRASH"NYI";
  }
}
template <typename T>
void MacroAssembler::branchSubPtr(Condition cond, Tswitch cond){
                                  Label* label) {
  switchma_sub32TestOverflow ,,;
    case Overflow:
      ma_subPtrTestOverflow(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 12
      break;
     caseNotSigned:
    case Zero:
    case Signed:
    case NotSigned:
      subPtr(src, dest);
      ma_b(      ma_b(dest,label );
    default:
    default:
      MOZ_CRASH("NYI");      (NYI)
  s,Register,
}
template  Labellabel java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
voidMacroAssembler:(   T&address,
                                           Label* label)breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  cond=  | cond= );
        ;
  Register=temps.)
  MOZ_CRASH(NYI)
java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
       ( ==Equal) AboveOrEqual:Below;
}
template <typename T>
void             Label  java.lang.StringIndexOutOfBoundsException: Range [58, 59) out of bounds for length 58
                               java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  c = |= ;
  Register tag = extractTag(tag :V,java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
}

template <typename T>                                   ){
void  java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 48
       
  MOZ_ASSERT(cond == Equal ||J java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 63
  (srcd)
                                      ){
}

template <typename  tag=java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 39
:  T ,
                                   Register dest) {java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  = | =)
  Register tag = extractTagRegister  java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  ma_cmp_set(dest, tag ImmTagSignExt(JS::detail::ValueUpperInclNumberTag),
             cond == Equal ? BelowOrEqual : Above);
}

template <typename T>
  (  (:detail:),
                                   Register dest) {
MOZ_ASSERT( =Equal |  =);
  Register tag = }
  ma_cmp_set(java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 1

template <typename T>
oid MacroAssembler::C , & ,
                                   Register dest) {
  MOZ_ASSERTc= | =NotEqual;
 dest);
  ma_cmp_setRegister java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
}

// Also see below for specializations of cmpPtrSet.
template <typename T1, typename T2>
void  Register tag =extractTag dest;
  ma_cmp_set(dest, lhs, rhs, cond);
}
template < ma_cmp_setd,tag () )java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
voidtemplate <typename,typenameT2
  dest,lhs,,cond;
}
template t java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 tempsthis;
  Register scratch = temps.Acquire();
sraiwscratch,src ;
  xor_(dest, src, scratch);
  void:Register    
}
void MacroAssembler::Register scratch = temps.Acquire();
    sraiw(,src,;
}

void xor_(dest, src, scratch
  fabs_ddest )java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
}
void MacroAssembler ;
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

void MacroAssemblerdest ;
  ma_add32(dest, dest, java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 1
}

voiddest)
  ma_add32(void :Imm32 java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 54
}

void MacroAssembler::add32(Imm32 imm, const Address& dest) {
  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
  Register  =.(;
  load32(dest, scratch2);
  ma_add32(  ma_add32(dest, src)
  store32MacroAssembler  const  java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void MacroAssembler::add32(const  ( )
ScratchRegisterScopet;
  Register scratch = temps.  UseScratchRegisterScope temps(th
  load32src,;
  addw(dest, dest, scratch);
}

 MacroAssembler:add64(egister64src, Register64 dest) {
  addPtr(src.reg, dest.reg);
}

void void MacroAssembler::add64(Register64 src  dest){
  ma_add64(dest.reg, dest.reg, imm);
}

void MacroAssembler::add64(Imm64 imm, 
  ma_add64(dest.reg, dest.reg, imm);
}

void  (.eg .,imm)java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
  fadd_d(dest, dest(.reg reg )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}

void MacroAssembler::java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 26
  void( ,java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 72
}
voidadddest  ;
  add(dest, dest, src)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

ma_add64dest ,;
  ma_add64(dest, dest, imm)
}

void UseScratchRegisterScopetempsthis;
   t;
  Register scratch = temps.Acquire();
  addPtr ;
  addPtr(scratch, java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
}
java.lang.StringIndexOutOfBoundsException: Range [19, 4) out of bounds for length 61
  Register   Acquire)
   =(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 25
  addPtri ;
  storePtr(scratch, dest);
}

void MacroAssemblerRscratch =Acquire);
U ()
   =Acquire(
   MacroAssembler(  
  addPtr(scratch( ,src;
}
java.lang.StringIndexOutOfBoundsException: Range [19, 4) out of bounds for length 57
est  )
}

void:and32immjava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 54
  , ;
}

voidjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 38
    load32 ;
}

void java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
  UseScratchRegisterScope temps(thisjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 38
   )
  and_, java.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
, ;
  store32java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 34
}

void and_(dest.reg, dest.reg, src.reg);
  java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
  Register scratch2 = temps.Acquirejava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 24
load32src ;
  and_(dest, dest, scratch2);
}
void java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
  ma_and(dest.reg, dest.java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 25
}

void Labellabel){
  and_(dest.reg, dest.java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 38
}

void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  and_(dest,     Assembler:java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
}

void MacroAssembler:     :
  (,dest ;
}

void MacroAssembler::andPtr(, u),)
      ;
}

void MacroAssembler::branch8case::
                             *label java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 ()
    =.)
  MOZ_ASSERT(scratch2break

  switch (      MOZ_CRAS" java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 40
caseE:
    case AssemblerLabel* 
    case UseScratchRegisterScopet)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    case ::
  ,java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 38
    case case Assembler::NotEqual:
caseA
          Ajava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      break;

    ::java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    rEqual:
        Assembler:java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
caseAssemblerL:
      load8SignExtendAddress,lhs.,;
      branch32(cond, scratch2, Imm32(int8_t(java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 43
      break;

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

void MacroAssembler
                             :
  );
  Register java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3
  s =lhsbase;

  computeScaledAddress(lhs, scratch2 Label*){

  switch (cond) {
    case Assembler::Equal:
    case Assembler::otEqual
     Assembler::Above:
    case Assembler::AboveOrEqual:
    case Assembler::Below:
    case Assembler::BelowOrEqual:
      switch (cond{
           ::java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
      break;

    case    Assembler:java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
    case load16ZeroExtend(, )
    caseAssembler:
    case Assembler break;
      load8SignExtend(Address(scratch2, lhs.offset), scratch2);
      branch32
    caseAssembler:GreaterThan:

    default:
      MOZ_CRASH("unexpected condition");
  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
}

void MacroAssembler::branch16(Condition cond, const Address&      (,scratch2,Imm32((rhs.value) ;
                              Label*       break;
  UseScratchRegisterScopeMOZ_CRASH" ")
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
  MOZ_ASSERT( =lhs.)

switch c){
    case Assembler::Equal:
    case Assembler::NotEqual:
    case :A:
    case Assembler::AboveOrEqual:
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
    case Assembler::BelowOrEqual:
      load16ZeroExtend                              * ) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
      (,scratch2 (r.alue) label;
      break;

    case             Label**label java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    case     =tempsAcquire)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
     ::
    case :LessThanOrEqualjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      ( )java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      branch32(cond, scratch2, Imm32(int16_t(rhs.   ()java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 38
      break;

    default:
      MOZ_CRASH("unexpected m(scratch2,rhs,label,)
  }
}
void void MacroAssembler::branch32(Condition cond, const AbsoluteAddressRegister    java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
           Label  java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  ma_bl   )
}ma_bs,rhs label )

void MacroAssembler MacroAssemblerConditioncond,const &java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
                              Label* label) {
   ma_bl,imm ,cond;
}

void   Register=.(;
                        java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  void MacroAssembler::branch32(Condition cond, const BaseIndex& java.lang.StringIndexOutOfBoundsException: Range [63, 66) out of bounds for length 45
  Register scratch2 = temps.Acquire();
  load32(lhs, scratch2);
ma_bscratch2, rhs,label )
}

void :branch32Conditioncond,constAddress   java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                              
   tempsthisjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  Register scratch2 = temps.Acquire();
  Register   .(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
, rhs, label )
}java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void MacroAssembler::branch32(Condition cond, const AbsoluteAddress& lhs,
                               rhs  ) {
  UseScratchRegisterScope temps(this);
 scratch2 = temps.Acquire();
  load32(lhs, scratch2);
  ma_bscratch2 ,label, cond;
}

branch32(   &lhs,
                              Imm32 rhs,                  =AssemblerG |
 java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 38
 =temps.(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  load32cond= : |cond =Assembler:,
  ma_b(scratch2, rhs, label, cond);
}

void MacroAssembler::branch32(Condition cond, java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 0
                             label java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  load32(lhs, scratch2)Labelsuccess *fail) 
  ma_b(scratch2, rhs, label, :N | =Assembler: |
}

void MacroAssembler::branch32(                  =Assembler: |
Imm32 , *) java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
 ( );
  ma_b(scratch2, imm, label, cond);
}
void o codesnot)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                              *success,Label*fail){
  MOZ_ASSERT(cond == Assembler::    )java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
                 cond =java.lang.StringIndexOutOfBoundsException: Range [23, 0) out of bounds for length 0
                 cond == Assembler::LessThanOrEqual ||
                 cond == Assembler::GreaterThan ||
                 cond= :GreaterThanOrEqual ||
                 cond                 =:|
 = :Above ||cond= :,
             "other condition codes not supported");

branchPtr ., (al.alue)success;
  if               =Assembler:GreaterThanOrEqual|
    jump(fail);
  }
}

void MacroAssemblerocodesnot)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
              Label  Label ){
  MOZ_ASSERT(java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 13
                 cond == Assembler::java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 3
                 cond == Assembler::void MacroAssembler::branch64(Condition cond, const Address& lhs,
                 cond = :GreaterThan|
                 cond == Assembler::GreaterThanOrEqual ||
                 = : |cond= : |
                 cond cond =Assembler: 
" notsupported";

  branchPtr(cond, lhs.reg, rhs.reg, success);
  if(){
    jump(fail);
  }
}                  = Assembler::reaterThanOrEqual |java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

::(ondition ,constAddress   ,
                              Label* success, Label* java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 52
  branchPtr,lhs,rhsreg, )
    cond==Assembler:|
                 cond == Assembler::java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 15
                 cond == void MacroAssembler::branch64(Condition cond, const Address& lhs,
                 = Assembler: |
                 cond == Assembler                              *label {
                 =:|=:AboveOrEqualjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
             "  MOZ_ASSERT(lhs.ba != cratch)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

   (,scratch;
  if (fail) {
    jump(fail);
  }
}

void java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
 rhs, Label ,Label* fail){
  MOZ_ASSERT(cond == Assembler::                                  FloatRegister frs2,*L {
                 =Assembler::essThan|
                  MacroAssembler::branchFloat ,FloatRegister,
                 cond == Assembler::                                 FloatRegister frs2 Label ){
r::GreaterThanOrEqual|
                 cond == Assembler::Below || cond java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
                 ::AboveOrEqual,
             "other condition codes not                                  *label) {

  branchPtr(cond, lhs, rhs.reg, success);
  ifma_mulPtrTestOverflow,dest ,label;
    jump(fail)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  }
}

  ne()
                               (:,reg (NTPTR_MIN,label);
Label ){
  MOZ_ASSERT(cond == Assembler::NotEqual || cond == Assembler::Equal,
"other  codes  supported";
  MOZ_ASSERT(lhs.base != scratch);
  MOZ_ASSERT(hs. =scratch)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

  loadPtr(rhs, scratch);
  
}

void void:branchPrivatePtrCcond,const(cond,,rhs,;
                                  java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 0
  BranchFloat64(cc, frs1, frs2                               Label  java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
}
MacroAssembler:( java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 72
                                  frs2 * L java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
oat32cc frs1,frs2,L,LongJump;
}

void MacroAssembler:(Condition  lhs ImmPtrrhsjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                                  Label*   if (rhs.value == nullptr && (cond == Zero NonZero){
  MOZ_ASSERT  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
ma_mulPtrTestOverflow(est, dest,src ;
}

void MacroAssembler::branchPtrCondition cond,Registerlhs  rhs,
  MOZ_ASSERT(= );
  negPtr(ma_blhs ,label ;
  branchPtr(Assembler::Equal, reg, ImmWord(java.lang.StringIndexOutOfBoundsException: Range [0, 53) out of bounds for length 1
}
void MacroAssembler::branchNeg32(                               Label* label) {
  (ond=Overflow;
  neg32(reg);
  branch32(Assembler:java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

 :branchPrivatePtr(onditioncond constAddress&lhs,
                                      Register rhs, Label* label) {
  branchPtr(cond  Registerscratch2=tempsAcquire(;
}

void   branchPtr(cond(cond scratch2,rhs,label)
                               Label* 
  , cond;
}

java.lang.StringIndexOutOfBoundsException: Range [40, 4) out of bounds for length 71
                               Label* label) {  java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 38
  loadPtr,scratch2;
}

void MacroAssembler::branchPtr(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 1
                               void MacroAssembler::branchPtr(Condition:C , &lhs rhs,
java.lang.StringIndexOutOfBoundsException: Range [35, 2) out of bounds for length 66
    ma_b(lhs, lhs, label, cond);
} {
    ma_b(lhs, rhs, label, cond);
  }
}

void MacroAssembler::branchPtr(Condition cond  (cond,scratch2 ,label;
                               
  ma_bvoidMacroAssembler:branchPtr( ,constAddress ,ImmWordrhs,
}

voidMacroAssembler:branchPtr(ondition ,Register lhs  java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
                               loadPtr( scratch2;
  ma_b(lhs, rhs, label,branchPtr(,scratch2  label);
}

voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                ) {
  UseScratchRegisterScope temps(this);Register   java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  Register scratch2 = temps.  Register scratch2  temps.();
 loadPtr(lhs,scratch2)
  (,scratch2,rhs,label)
}

void void MacroAssemblerbranchPtr( cond  &,
Label* java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
this;
   =java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 38
 lhs ;
  branchPtr(cond, scratch2, rhs, label);
}

(Conditioncond    rhsjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
                               Label* label) {
   =temps)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
   scratch2 =temps.Acquire)
  loadPtr(lhsjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  c  ,l)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}

:branchPtr A ,rhsjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
                               Label*   ,;
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.AcquireImmWord java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 59
  loadPtr(lhs, scratch2);
  branchPtr(cond, scratch2, rhs, label);
}

void MacroAssembler::branchPtrjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 38
   rhs ;
  UseScratchRegisterScope temps(this);
  Registervoid:( ,AbsoluteAddress,
  loadPtr(lhs, scratch2                                   , java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 60
  branchPtr              =)
}

void load32(lhs, scratch2);
                               ImmWord rhs, Label* label)  ( ;
  UseScratchRegisterScope temps(thisjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   scratch2 .)
  loadPtr(lhs, scratch2);
  branchPtr(cond, scratch2, rhs, label)java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 65
}

java.lang.StringIndexOutOfBoundsException: Range [19, 4) out of bounds for length 73
                               Register rhs, Labelload32lhs java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  UseScratchRegisterScope tempsv :java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 67
  =)
  loadPtr(lhs, scratch2);
  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 40
}

voidjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                               Registerrhs,Label*label){
  UseScratchRegisterScope                                       * label) {
  Register scratch2 = temps.Acquire();
  loadPtr(hs );
  Register scratch2  .(;
}

void MacroAssembler::branchPtr(Condition
                                ,Label* 
  UseScratchRegisterScope temps(this);
  scratch2  java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 38
  loadPtr(lhs, scratch2);
  void:Condition  
}

void MacroAssembler::UseScratchRegisterScope temps;
                                      java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  MOZ_ASSERT  cond ;
             cond == NotSigned);
   MacroAssembler::branchTestBigIntTbconst java.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78
  Register scratch2 = temps.  UseScratchRegisterScope temps(this);
  load32(lhs  Register  = temps.();
  and32(rhs, scratch2);
  ma_b(scratch2, scratch2  unboxBigInt(, scratch2)
}

void MacroAssembler::branchTest32(Condition cond, const  ma_bscratch2,Imm32(0,label,b  :Equal;
                                  Label* label) {
  MOZ_ASSERT(cond = Zero |cond= NonZero |  =Signed|
             = );
  UseScratchRegisterScope temps(this  (= | = NotEqual;
Register  =temps.(;
  load32(lhs, scratch2);
  and32(rhs, scratch2);
  );
}
 MacroAssembler::branchTestBigInt(Condition cond, Register tag,
                                      Label* label) {
  MOZ_ASSERT(cond == Equal |                                       * label){
(tag,ImmTagSignExtJSVAL_TAG_BIGINT), label,cond;
}

 MacroAssembler:branchTestBigInt(ondition cond  ValueOperand value,
                                      Label* label) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  splitSignExtTag(value, scratch2);
  void MacroAssembler:(Condition ,  Address& ,
}

void               Label  java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                                      Label* label) {
  UseScratchRegisterScope  (, ;
  Register scratch2 = temps.Acquirejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  Register tag = extractTag(address, scratch2);
  branchTestBigInt(cond, tag, label);
}

void MacroAssembler::branchTestBigIntjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 47
                                      Label* label) {
 t)
  Register scratch2 = temps. Label*  java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
Register a java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    ma_b( java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 54
}
:boolb   
                                            Label* label) {Label  java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 )
    ma_b(tag)  ;
  unboxBigInt(value, scratch2
, :),scratch2;
  ma_b(scratch2, Imm32(0), label,  Label*label java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
}
void MacroAssembler::branchTestBoolean v,;
                                       Label* label) {
  MOZ_ASSERT(cond == java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  ma_b(tag, ImmTagSignExt(JSVAL_TAG_BOOLEAN),                                       Label* label
}

TestBoolean condjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                                       const java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 0
                                       Label*                                       Label* label* java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
temps(his);
  Register java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
  splitSignExtTag(value, scratch2);
  branchTestBoolean(cond, scratch2, label);
}

 cond, constAddress address,
                                       Label* label) {
  UseScratchRegisterScope0 java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 37
  Register scratch2 = temps.Acquire();
  Registertag =extractTagaddress,scratch2);
  branchTestBoolean(cond}
}

void MacroAssembler::branchTestBoolean(Condition cond, const  Label* label {
                                       Label* label) {
UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  Register tag = extractTag
  (cond tag,);
}
void MacroAssembler::branchTestBooleanTruthy(bool  (ond,address, abel;
                                             Label*
   temps(this);
  Register scratch2 = temps.Acquire();
  unboxBoolean(value, scratch2);
  ma_b(scratch2, scratch2, label, b  const ValueOperand& address,
}
void MacroAssembler::branchTestDouble(Condition cond                                       * label) java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                                      * label){
  MOZ_ASSERT(cond == Equal || cond == NotEqual) Label ){
  Condition actual = (cond == Equal) ?   MOZ_ASSERT(cond == Equal || cond == NotEqual
  ma_b
}

void MacroAssembler::branchTestDouble                                     * label) {{
                                      Label* label)  UseScratchRegisterScope();
  UseScratchRegisterScope.(;
   scratch2 .(;
  splitSignExtTag(value, scratch2);
  branchTestInt32,scratch2,;
}

void MacroAssemblervMacroAssembler:java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 76
                                      Label* label) {
);
  Register     Acquire)
R=(,;
  branchTestInt32(  ;
}

void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                      Label* label) {
  UseScratchRegisterScope temps(this);
  Register  scratch2 = temps.Acquire();
  Register tag = extractTag(address, scratch2);
 branchTestDouble(, tag,label;
}

void MacroAssembler::branchTestDoubleTruthy(bool b, FloatRegister
                                            Label* label) {
   fpscratch*;
  loadConstantDouble(0.0, fpscratch);
  DoubleCondition cond = b ? DoubleNotEqual  UseScratchRegisterScope ()
java.lang.StringIndexOutOfBoundsException: Range [26, 2) out of bounds for length 46
}
void MacroAssembler::branchTestGCThing(  ma_b(scratch, scratch, label, b ? NonZero :
                                       Label* void MacroAssembler::branchTestMagic(Condition cond, Register tag,
  branchTestGCThingImpl(cond, address, label)  MOZ_ASSERT(ond = Equal |cond= NotEqual)
}

void MacroAssembler:: MacroAssembler::branchTestMagic   java.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 76
                                       Label* label)   tempst)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  Register=( ;
}

void::branchTestGCThingC condjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                                       void  &,
Label )
  branchTestGCThingImpl(cond, address, label);
}
:branchTestInt32cond java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                                     Label* label) {
  MOZ_ASSERT(cond == Equal || cond == java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 36
  ma_b(tagvoid:ranchTestMagicConditioncond ValueOperand ,
}

void MacroAssembler::branchTestInt32(Condition cond,    this;
          Label){
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  splitSignExtTag  branchTestMagic(ond scratch2 ;
  branchTestInt32(cond, scratch2, label);
}
voidMacroAssemblerb(   Address&java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
void MacroAssembler::branchTestInt32(Condition conduint64_t  ()asRawBits;
                                     Label* label) {
  UseScratchRegisterScope temps(this   .cquire)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

  Registertag= extractTag(address,scratch2)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  branchTestInt32(cond, tag, labeluint64_tmagic=();
}

void MacroAssembler::branchTestInt32   temps(his;
     .(java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
  UseScratchRegisterScopejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  Register                  *)
  java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  branchTestInt32(cond, tag
}
void MacroAssembler
Label* label){
  UseScratchRegisterScope temps(this)                                    *label){
  Register scratch =   Register scratch2 = temps(;
  SignExtendWord(scratch, value.valueReg());
  ma_b(splitSignExtTag ;
}
void MacroAssembler:
                                       java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
( =  |cond=NotEqual;
  Registertag=( ;
}

MacroAssembler: ,Addressjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                                     Label* label) {
  UseScratchRegisterScopetemps(his;
  Register scratch2 = temps.Acquire();
  Register tag = extractTag(                              * label){
  branchTestMagiccond,tag,label)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}

voidMacroAssembler:branchTestMagic(Condition cond,constBaseIndex&address
                          Label*label 
  UseScratchRegisterScope temps(this);void MacroAssembler:branchTestNumberCondition ,Register ,
  Register scratch2 = temps.Acquire();
  Register   extractTag(ddress scratch2)
branchTestMagic(ond , label)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}

void                                       *label){
                                     Label* label) {
  UseScratchRegisterScope  temps(his;
  Register scratch2 = temps.Acquire();
splitSignExtTagv,scratch2)
  branchTestMagicsplitSignExtTag(alue scratch2);
}

 :branchTestMagicC cond,constAddress ,
                                     JSWhyMagic why, Label* label) {
  java.lang.StringIndexOutOfBoundsException: Range [44, 10) out of bounds for length 47
  UseScratchRegisterScope temps(this);
 Registerscratch  tempsAcquire)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  (valaddr scratch);
  ma_b(scratch, ImmWord(magic), label, cond);
}

void MacroAssembler:branchTestMagic( ,const BaseIndex valaddr,
                                     JSWhyMagic why, Label* label) {
  uint64_t magic = MagicValue(why).asRawBits();UseScratchRegisterScope;
  UseScratchRegisterScope splitSignExtTag(value, scratch2
=java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 37
  loadPtr(:java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 77
  ma_b(scratch, ImmWord(magic), label, cond);
}
void MacroAssembler::branchTestNull(Condition cond, Register tag,
                                    Label* label) {
  MOZ_ASSERT(cond == Equal || cond == NotEqual);
  ma_b(tag, ImmTagSignExt(JSVAL_TAG_NULL), label, cond);
}

void MacroAssembler::branchTestNull(Condition cond, const ValueOperand& value,
                                    Label* label) {
  UseScratchRegisterScope temps();
     scratch2 =temps.(;
  splitSignExtTag(value, scratch2);
  branchTestNull(cond, scratch2, label);
}

void MacroAssembler::branchTestNull(Condition cond,  branchTestObject(  label)
                                    Label* label) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  Register tag =                     Label label){
  branchTestNullcond tag,label)
}Register  .Acquire

void MacroAssembler::branchTestNull(  ( ,)
                                    Label* label) {
  UseScratchRegisterScope temps(this)                                       &,
Register  .(;
  Register tag = extractTag(address, scratch2);
  branchTestNull(cond, tag, label);
}
void MacroAssembler::branchTestNumber(Condition cond, Register tag,
                                      *label) {
  MOZ_ASSERT(  splitSignExtTag, ;
  Condition  (, , label);
  ma_b(tag, ImmTagSignExt(JS::detail::ValueUpperInclNumberTag}
}

void MacroAssembler:branchTestNumber(Condition cond const ValueOperand ,
abel) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  splitSignExtTag((value, scratch2);
  ma_b(,ImmTagSignExt(JS:detail::ValueUpperExclPrimitiveTag), label,
}
void MacroAssembler::branchTestObject(Condition cond, Register tag,
                                     *label {
  MOZ_ASSERT(cond == Equal || cond == NotEqual);
void:branchTestPtr(Condition ,Register lhs,Register rhs,
}

void MacroAssembler::branchTestObject(                                   Label* label{
                                      * label {
  UseScratchRegisterScope temps(this             cond = );
  Register  =temps.cquire)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  splitSignExtTag(UseScratchRegisterScopethis;
      Register scrat  .cquire)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
}

void MacroAssembler::branchTestObject(Condition cond, const Address& address,
                                      Label* label) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
Register tag=extractTag( )java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  branchTestObject(cond, tag, label);
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

void MacroAssembler::branchTestObject(Condition cond,     =.cquire(;
                                      Label* label) {
   temps(this));
  Register scratch2 = temps.Acquire();
  Register tag ma_b(scratch,scratch,java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  branchTestObject(cond, tag, label);
}
void MacroAssembler::branchTestPrimitive(Condition cond,
onstValueOperand&value,
                                         Label* label) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  splitSignExtTag(value cond==);
  branchTestPrimitive(cond, scratch2, java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 38
}
 :( ,Registertagjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
                                         java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 1
  MOZ_ASSERT(cond == Equal || cond == NotEqual Imm32 , Label* java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
ma_btag,:detail:) java.lang.StringIndexOutOfBoundsException: Range [73, 74) out of bounds for length 73
      (cond = Equal  Below AboveOrEqual);
}
void :branchTestPtrCondition , Register ,Register ,
               Label label) {
  MOZ_ASSERT(cond == Zero || cond == NonZero || cond == Signed ||
              :branchTestStringCondition ,  tag
( = rhs java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    ma_b(  ma_b(tag,) ,;
  } else {
    UseScratchRegisterScope temps(this);
  =temps.cquire(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    and_(scratch, lhs, rhs  tempst)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    ma_b(cratch scratch, label, cond);
  }
}

::branchTestPtr( cond, Registerlhs,Imm32 rhs,
                 Label*label){
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
              = )java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  UseScratchRegisterScope temps(this);
  Register scratch =temps.cquire(;
  (, lhs,rhs)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  ma_b(scratch, scratch, label, cond);
}

void MacroAssembler::branchTestPtr(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 1
Label  java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
o|= java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 65
             cond=NotSigned;
  UseScratchRegisterScope temps(this);
  Register scratch = temps.Acquire();
ma_and(scratch, lhs, rhs);
  ma_b(scratch, scratch, label, cond);  Register tag extractTag(,scratch2)
}

void MacroAssembler::branchTestPtr :java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 78
                                   Imm32 rhs, Label* label  java.lang.StringIndexOutOfBoundsException: Range [31, 25) out of bounds for length 38
   ()
 =temps.(;
  loadPtr(lhs, scratch2);
  branchTestPtr 0 label, b ? NotEqual : Equal);
}
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                            * label) {
  MOZ_ASSERT(cond == Equal || cond == NotEqual);
  ma_b(tag, ImmTagSignExt(JSVAL_TAG_STRING), label MOZ_ASSERT(ond = |  = );
}

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

void MacroAssembler::java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 35
                                      Label* label) {
(;
  Register scratch2 =                                      * java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  Register tag = extractTag(  java.lang.StringIndexOutOfBoundsException: Range [31, 25) out of bounds for length 38
  branchTestString(condt =extractTag()
}

void :java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 77
                                      * label){
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
   tag =( );
    Register scratch2 = temps.();
}
MacroAssemblerbjava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 78
                               *  
  UseScratchRegisterScope  MacroAssembler::branchTestUndefin java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  Register scratch2 = temps.Acquire();
  unboxString( temps;
load32sjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 66
  ,0,    :;
}
void  c,java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 45
                                      void:java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 80
  MOZ_ASSERT(cond == Equal || cond == NotEqual);
  ma_b  =A(;
}

void MacroAssembler::branchTestUndefined(cond, tag,
                                      Label
  UseScratchRegisterScope(;
                                            &,
  splitSignExtTag(value,                               * 
  (cond  )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
}

 MacroAssembler:branchTestSymbol   &a,
                                      Label* label) {
  UseScratchRegisterScope temps(this                                         * label){
  scratch2 = temps.Acquire(;
  Register tag =    (),label,cond;
  branchTestSymbol(cond, tag, label);
}

void MacroAssembler::branchTestSymbol(Condition cond, const template<typename T>
                                      Label* label) {
  voidMacroAssembler:branchTestValue(   &lhs,
  Register scratch2 = temps.Acquire();
  Register tag = extractTag(address, scratch2);
b(,tag label);
}
 (,lhs,rhsvalueReg) label)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
   const&,
                                         Label* label) {
  UseScratchRegisterScope temps(this);
  loadPtr,;
  splitSignExtTag(java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 19
  (,,label;
}

void MacroAssembler::branchTestUndefinedLabel ){
                                           // The Zfa fcvtmod.w.d instruction handlesjava.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 69
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire()    return;
  Register tag = extractTag
  branchTestUndefined( tag,label)
}

void MacroAssembler::branchTestUndefined  /Inthe  of java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 61
                                         const BaseIndex& Trunc_l_ddest )
                                         * ){
 empsthis)
  Register scratch2 = temps.Acquire();
  Register tag = extractTag(address, scratch2);
  branchTestUndefined(cond, tag, label)ma_li(scratch,Imm64('ffffffff);
}
void MacroAssembler::branchTestUndefined(Condition cond,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                         Label* label  branchPtr(:BelowOrEqual, scratch,ImmWord1) fail);
  MOZ_ASSERT(  java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 36
  ma_b(tag :( ,
}
template <typename T>
void MacroAssembler::  / Convert scalar to signed 64-bit fixed-point, rounding toward zero.
                                     const ValueOperand  // In the case of overflow or NaN, the output is saturated.
   Trunc_l_d(dest src;
  branchPtr(cond, lhs, rhs.valueReg(), label);
}
void MacroAssembler::branchToComputedAddress(const BaseIndex& java.lang.StringIndexOutOfBoundsException: Range [0, 66) out of bounds for length 28
  UseScratchRegisterScope  /  32 to the  '  .
  Register scratch2 = temps.Acquire();
  (,scratch2);
  branch(scratch2);
}
void :FloatRegistersrc,
                                                        Register dest( java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 41
                                                        java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 3
  // The Zfa fcvtmod.w.d instruction handles exactly this conversion.
  if (HasZfaExtension()) {
    fcvtmod_w_d(dest, src);
    return;
  }

   this;

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

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

  // Unsigned subtraction of INT64_MAX returns 1 resp. 0 for INT64_{MIN,MAX}.
  Register scratch = temps Clear_if_nan_s(est,src;
  ma_li(scratch, Imm64 
  sub(scratch, dest, scratch);

  // Fail if the result is saturated.
  branchPtr(Assembler::BelowOrEqual

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

void ::(Register64 src, Label* label) {
                                                 Register dest, Label* fail) {
  // Convert scalar to signed 64-bit fixed-point, rounding toward zero.
 overflow  NaN   .
  // In the case of -0, the output is zero.
  (, )

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

  // Sign extend lower 32 bits to test if the result isn't an Int32.
  {
 temps()java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    Register scratch =.Acquire();

}
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  }
}
void MacroAssembler::branchTruncateFloat32MaybeModUint32
                                                    Register dest,
                                                         Label* fail) {
  // Infallible operation on riscv64.
  truncateFloat32ModUint32(void :clampIntToUint8(Register reg) {
}

void   // If reg is<0 then wewant  clampto.
                                                  Register dest,     UseScratchRegisterScope temps()
  // Convert scalar to signed 64-bit fixed-point, rounding toward zero.
  // In the case of overflow or NaN, the output is saturated.
  // In the case of -0, the output is zero.
  Trunc_l_s(scratch,scratch)

  // Zero if NaN, so we don't take the failure path below.
  Clear_if_nan_sjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

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

    move32SignExtendToPtr(dest,    r 255;
    branchPtr(Assembler::NotEqual, dest, scratch,java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 14
  }
}

void  Clz32dest, src;
  // No-op on 64-bit platforms.
}

void MacroAssembler::branchUInt64NotInPtrRange  (dest.reg,src.);
  branchTest64(Assembler::Signed, src, srcjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (., .)

voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
src )java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
}

void MacroAssembler::byteSwap16ZeroExtend(Register  Register scratch2=tempsAcquire)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  ByteSwap(src, src, 2, /* zeroExtend= */ true);
}

void MacroAssembler::java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 29

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

voidMacroAssembler:( reg){
  // If reg is < 0, then we want to clamp to 0.
  {
    UseScratchRegisterScope temps(this);
    Register scratch = temps.Acquire();

 1 :)&
     :
    neg(load16SignExtendl )
    and_      (,scratch2 java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 66
  }

/java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  Label skip;
  ma_b(reg, Imm32(255)
  {
    ma_li(reg, Imm32(255));
  }
  bind(&skip);
}

void MacroAssembler::clz32(Register src, Register dest, bool knownNotZero) {
  Clz32(  MOZ_ASSERT(lhs != scratch && dest != scratch);
}
void MacroAssembler::clz64(Register64cmp32Load32(,lhs ,src )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  Clz64(dest.reg, src.reg);
}

void MacroAssembler::ctz64(Register64 src, Register64 dest) {
  Ctz64(:InvertCondition(ond) ,rhs &skip)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
}

void MacroAssembler}
                              Register java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  temps(this);
  Register scratch2 =                            ,Registerdest java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
M( =lhs.base);

  switch (cond) {  (s)
    case :Equal
    case Assembler:
    case Assemblervoid :cmp32LoadPtrConditioncond  Address , rhsjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    case Assembler::AboveOrEqual:
    case Assembler::Below:
    case Assembler::BelowOrEqual:
      (lhs scratch2)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 13
     ;

    case Assembler::GreaterThan:
    case Assembler::GreaterThanOrEqual:
    case Assembler::LessThan:
    case Assembler::void MacroAssembler::cmp32Move32(Concond,Register lhs,Imm32 rhs,
      load16SignExtend(hsscratch2);
      ma_cmp_set(dest, scratch2, Imm32ma_cmp_mvdest, lhs,rhs, src, cond);
      break;

    default:
      MOZ_CRASH("unexpected condition");
  }
}

void MacroAssembler::cmp32Load32(Condition cond, Register lhsma_cmp_mv(est,lhs,rhs,src,cond)
                                 const Address& java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 0
                                 Register dest) {
  UseScratchRegisterScopetemps(this;
  Register scratch = temps.Acquire();
  MOZ_ASSERT(lhs != scratch && dest != scratch);
  load32(rhs, scratch)java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 38
  cmp32Load32(cond)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
}

MacroAssembler:(ondition cond  lhs,Register,
                                 const Address Registersrc,Registerdest java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  ma_cmp_mv(,lhs,rhs ,cond;
  branch32(Assembler::InvertCondition(}
,destjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  bind(&skip);
}

 cond, Register
                                 Address src,Register dest {
  Label skip;
  branch32voidMacroAssembler:cmp64Set( cond Addresslhs,Register64,

  bind(&skip);
}

( cond ,java.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 80
                                  const Address& srcRegisterdest){
  Label skip;
 branch32(Assembler:InvertConditioncond)lhs,rhs skip)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  loadPtr(src, dest);
  bind(&skip);
}

void     case Assembler:
                                 Registersrc Register dest){
  ma_cmp_mv(dest, lhs, rhs, src, cond);
}

void MacroAssembler::cmp32Move32(Condition cond, Register lhs,     caseAssembler:Below:
                                 Register src, Register dest) {
  ma_cmp_mv(dest, lhs, rhs, src, cond);
}

void MacroAssembler::cmp32Move32(Condition cond, Register lhs,
                                 const Address& rhs, Register src,
                            dest){
  UseScratchRegisterScope temps(this);
2 =temps.Acquire();
  MOZ_ASSERT(lhs != case Assembler::LessThan
l(,)
  cmp32Move32(cond, load8SignExtend(hs,scratch2;
}
    dest ,Imm32int8_t(hs.)), )
                                  Register src, Register dest) {
  ma_cmp_mv(dest, lhs, rhs, src, cond);
}
void MacroAssembler::cmp64Set(Condition java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 1
                              Register dest) {
  ma_cmp_set(dest, lhs.reg, rhs.reg, cond);
}
oidMacroAssembler:cmp64SetCondition cond,Register64   rhsjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
)
  ma_cmp_set(dest, lhs}
}
void MacroAssembler::cmp64Set(Condition cond, Address lhs, Register64 rhs,
                              Register dest) {
  ma_cmp_set(dest, lhs,   MOZ_CRASH(NYI";
}
void MacroAssemblervoidMacroAssembler:cmpPtrMovePtr cond  lhs,
                             dest)
  ma_cmp_set(dest, lhs, ImmWord(uint64_t(rhs.value)), cond);
}
void MOZ_CRASH"";
                             Register dest) void MacroAssembler::ctz32(Register src, Register dest, bool knownNotZero) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  MOZ_ASSERT(scratch2 != lhs.base);

  switch (cond) {
    case Assembler:Equal
    case Assembler::NotEqual:
    case Assembler::Above:
    case Assembler::AboveOrEqual:
    case Assembler::Below:
    case Assemblerr:divFloat32( ,FloatRegister) java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
      load8ZeroExtend(lhs, scratch2);
      ma_cmp_set(dest, scratch2, void MacroAssembler::divDouble(FloatRegister src, FloatRegister dest) {
      break;

    case Assembler::GreaterThan:
    case Assembler::GreaterThanOrEqual:
    caseAssembler:LessThan:
    case Assembler::LessThanOrEqual:
      load8SignExtend(lhs, scratch2);
ma_cmp_set(, scratch2 ((.alue),cond;
      break;

    default:
  / dest := src XOR mask
  }
}
void java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 4
                                   Register src, Register dest) {
  xor_(dest, src.valueReg(), scratch);
  Register scratch2  (scratchdest ;
cmpPtrSetcond,lhs, rhs, scratch2)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void MacroAssembler::cmpPtrMovePtr(Condition cond, Register   loadValue, ValueOperand(dest);
 src,  dest){
  MOZ_CRASH("NYI");
}

void MacroAssembler::voidconstBaseIndexsrcd,
const&  java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
                     ) {
  MOZ_CRASH("NYI");
}

:Register,,knownNotZero{
  Ctz32(dest, src);
}

lshift32src dest)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
                                  Label* label) {
  subPtr(rhs, voidf(egister,dest java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  branchPtr(cond:inc64 dest {
}
voidRegister =tempsAcquire(;
  fdiv_sdest,dest,src);
}

void MacroAssembler::divDouble(FloatRegister src, FloatRegister dest) {
  fdiv_d(dest, dest, src);
}
voidMacroAssembler:fallibleUnboxPtrconstValueOperand src,Register dest,
                                      JSValueType type, Label* fail
  MOZ_ASSERT(type == JSVAL_TYPE_OBJECT || void MacroAssembler::load32SignExtendToPtr(const  dest){
             type == JSVAL_TYPE_SYMBOL || type ==  load32(rc dest)
  // dest := src XOR mask
//scratch=java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 39
  // fail if scratch != 0
  //
  // Note: src and dest can be the same register
 temps;
  Register scratch = temps.Acquire();
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
 ImmShiftedTagtype,scratch)
  xor_(dest,  slliwdest src,.alue& xf;
  srli(scratch,java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 ( 0 ,Assembler:otEqual;
}

void MacroAssembler::java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1
                                       MacroAssembler:lshift64(mm32 imm, dest) {
  loadValue(src,( = & value< )java.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
 fallibleUnboxPtr(est, ,type )java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
}

void MacroAssembler::fallibleUnboxPtr(const BaseIndex& src, Register dest,
                                      JSValueType voidMacroAssembler:  )java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  loadValue(src, ValueOperand(dest));
fallibleUnboxPtr(() dest,type,fail)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
voidMacroAssembler:flexibleLshift32Register src, Register dest) {
  lshift32(src, dest);
}
oid:(java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 78
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
}
c, Register) {
  rshift32(src, destminMax32lhs  /* isMax = */ false);
}
void MacroAssembler::inc64(AbsoluteAddress :(egisterlhs,Imm32rhs ){
  UseScratchRegisterScope temps(this);
.Acquire)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  Register scratch2 = temps.java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
 scratch uintptr_tdesta);
  ld(scratch2, scratch, 0);
  addi(scratch2, scratch2, 1);
  sd(scratch2, scratch
}

void MacroAssembler::  minMax32(lhs, rhs, dest, /* isMax = */ true);
  load32(src, dest);
}
void MacroAssembler::loadAbiReturnAddress(Register dest) { movePtr(ra, dest); }

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

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

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

void MacroAssembler::lshift64(Register shift, Register64 dest) {
  sll(dest.reg, dest.reg, shift);
}

void MacroAssembler::lshift64(Imm32 imm, Register64 dest) {
    .   ;
  slli(dest.reg, dest.reg, imm.value);
}
:shift java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 63
  sll(dest, dest, shift);
}

void
  lshiftPtr(imm, dest, dest);
}

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

void MacroAssembler
  lshiftPtr(shift, srcDest);
}

void MacroAssembler::min32(  Float64Max(srcDest, srcDest, othejava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 rhs dest,/
}

void MacroAssembler::min32(Register lhs, Imm32  Float32Max(rcDest,srcDest,other;
  minMax32(lhs, rhs, dest, /* isMax = */ false);
}

void MacroAssembler::max32(Register lhs, Register rhs, Register dest) {
  minMax32(lhs, rhsif!( 
}s(;

void MacroAssembler: Fother java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    ;
}

void MacroAssembler::minPtr(Register lhsbool)java.lang.StringIndexOutOfBoundsException: Range [49, 50) out of bounds for length 49
  minMaxPtr(lhs, rhs
}

void MacroAssembler::minPtr(Register lhs, ImmWord rhs, Register dest) {
  minMaxPtr(lhs, rhs, dest, /* isMax = */ false);
}

void MacroAssembler:: SignExtendShortdest ;
  minMaxPtr(lhs, rhs, dest, /* isMax = */ true);
}

void MacroAssembler::maxPtr(Register lhs, ImmWord rhs, Register dest) {
  minMaxPtr(lhs, rhs, mjava.lang.StringIndexOutOfBoundsException: Range [51, 42) out of bounds for length 73
}

void:move32SignExtendToPtrjava.lang.StringIndexOutOfBoundsException: Range [55, 51) out of bounds for length 73
                               bool handleNaN) {
  Float64MaxsrcDest srcDest,other;
}
void MacroAssembler::maxFloat32(FloatRegister other, FloatRegister srcDest,
                                bool handleNaN) {
  Float32Max(srcDest, srcDest, other);
}
voidvoid :move32To64ZeroExtendRegistersrc,Register64){
  if (!barrier.isNone()) {
    sync();
  }
}
void MacroAssembler::minDouble(FloatRegister other, FloatRegister srcDest,
                               bool handleNaN) {
  Float64Min(srcDest,srcDest, other);
}
void MacroAssembler::minFloat32(FloatRegister other, FloatRegister srcDest,
                                bool
  (,;
}
}
  SignExtendShort(dest, src);
}
 MacroAssembler:(Register src, Register64 dest) {
  SignExtendShort(dest.reg, src( java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
}
void MacroAssembler::java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 24
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
}
void MacroAssembler::move16SignExtendToPtr(Register src, Register dest) {
  move16To64SignExtend(src, Register64(dest));
}
void :move32SignExtendToPtrRegister src,Register dest) {
  SignExtendWord(dest, src);
}
voidjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 SignExtendWord(dest.eg src);
}
void MacroAssemblerfmv_x_d(est.reg,src)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  ZeroExtendWord(dest.reg, src
}
void MacroAssembler::move32ZeroExtendToPtr(Register src, Register dest) {
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}
 java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 62
  movePtr(src.reg
}

void MacroAssembler::move64(Imm64 imm, Register64 dest) {
  movePtr(ImmWord(imm.value), void:moveGPRToFloat32Registersrc, FloatRegisterdest java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void MacroAssembler::move64To32java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
SignExtendWorddest reg)
}

 MacroAssembler:move8ZeroExtend(Register src, Register dest {
  andi(dest, src, 0xFF);
}

java.lang.StringIndexOutOfBoundsException: Range [67, 19) out of bounds for length 67
  SignExtendByte(dest, src);
}
void MacroAssembler::move8To64SignExtend,srcDestimm;
  SignExtendByte(dest.reg, srcjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}
MacroAssembler:moveDoubleToGPR64FloatRegistersrc,Register64dest {
  fmv_x_d(dest.reg, src);
}

void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  fmv_d_x(,srcreg;
}
void MacroAssembler::moveLowDoubleToGPR(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
MOZ_CRASH(    ";
}
 :moveFloat32ToGPR ,Register) java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  fmv_x_wdest,src)
}
void  mul64(mm,dest)
  fmv_w_x(java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
} :java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 73
void MacroAssembler::moveFloat16ToGPR(java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 42
 HasZfhminExtension;
  fmv_x_h(dest, src);
}
 java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 73
  MOZ_ASSERT(HasZfhminExtension());
  fmv_h_x(dest, src);
}
void :mul32Register rhs, ){
  mulw(srcDest, srcDest, rhs);
}

void MacroAssembler::mul32(Imm32 imm, Register srcDest) {
  ma_mul32(srcDest, srcDest, imm);
}

void MacroAssembler::mulHighUnsigned32(Imm32 imm, Register src, java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 60
  ma_mulhu32(dest, src, imm);
}

void MacroAssembler::mul64(Imm64 imm, const Register64& dest) {
  ma_mul64(dest.reg, dest.reg, imm);
}

void MacroAssembler::mul64(Imm64 immvoid MacroAssembler::mulFloat32(FloatRegister src, FloatRegister dest) {
                           const Register temp) {
  MOZ_ASSERT(temp == Register::Invalid());
  mul64(imm, dest);
}

void MacroAssembler::mul64(const java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 1
                           const RegistermulsrcDest  ;
  MOZ_ASSERT(temp == Register::Invalid());
  mul(dest.reg, dest.reg, src.reg);
}

void MacroAssembler::mulBy3(Register src, java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 0
  UseScratchRegisterScope java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   scratch  tempsAcquire)
  MOZ_ASSERT(src != java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
  add(scratch, src, src);
  add(dest, scratch, src);
}
java.lang.StringIndexOutOfBoundsException: Range [19, 4) out of bounds for length 71
  fmul_d(dest, dest, voidMacroAssembler:not32(Register  not_,) }
}
:I,tempjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
                                  FloatRegister destMacroAssemblero(egistersrc,Register){or_dest dest,src;}
  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
  Register scratch = temps.Acquire();
  void MacroAssembler::or32(Imm32 imm, Register srcsrc, imm);
  movePtr(imm, scratch);
  loadDouble(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
(fpscratch ;
}
void MacroAssembler::mulFloat32(java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 38
  fmul_s(dest, dest, src);
}
(constRegister64 ,const & srcDest java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
  mul(srcDest.reg, srcDest.reg, rhs.reg);
}
void MacroAssembler::mulPtr(Register rhs, Register srcDest) {
  mul(srcDest, srcDest, rhs);
}
voidjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
voidMacroAssembler::r64Imm64 imm Register64 dest) {
}

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

void java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0

void:( regnegregr) }

void:imm (java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 80

void   ma_or(dest(  ;
void MacroAssembler::not32(Register reg) { not_(reg, 

 MacroAssembler::otPtrRegister reg { not_(reg, reg); }

void MacroAssembler::or32(Register src, Register dest) { or_(dest, dest, src); }

32 imm,Register dest){ma_ordest, dest ) }

void MacroAssembler::or32(Imm32void MacroAssembler::popcnt64(Register64 input, Register64 output,
  ma_or(dest, src, imm);
}                               tmp) {

void MacroAssembler::or32(Imm32 imm, const Address& dest) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
  ma_or(scratch2, scratch2, imm);
           bool) {
}

void MacroAssembler::or64(Register64 src, Register64 dest) {
  or_(dest.reg, dest.reg, src.reg);
}

void MacroAssembler::or64(Imm64 imm, Register64 dest) {
  ma_or(dest.reg, dest.reg, imm);
}

void MacroAssembler::orPtr(Register src, Register dest) {
  or_(dest, dest, src);
}

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

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

void MacroAssembler::popcnt32(Register input, Register output, Register tmp) {
  Popcnt32(output, input, tmp);
}
void MacroAssembler::popcnt64(Register64 input, Register64 output,
                              Register tmp) {
  Popcnt64(output.reg, input.reg, tmp);
}
void MacroAssembler::quotient32(Register lhs, Register rhs, Register dest,
                                bool isUnsigned) {
  if (isUnsigned) {
    divuw(dest, lhs, rhs);
  } else {
    divw(dest, lhs, rhs);
  }
}

void MacroAssembler::quotient64(Register lhs, Register rhs, java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 19
                                bool isUnsigned)     java.lang.StringIndexOutOfBoundsException: Range [10, 11) out of bounds for length 10
  if (isUnsigned) {
    divu(dest, lhs, rhs);
  } else {
    div(dest, lhs, rhs);
  }
}

void java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
                                 bool isUnsigned) {
  if (isUnsigned) {
    remuw(dest, lhs, rhs);
  } else {
    remw(, lhs rhs);
  }
}

void MacroAssembler::remainder64(Register lhs, Register rhs, Register dest,
                                 bool isUnsigned)  if(sUnsigned java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  if (isUnsigned) {
    remu(java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
  } else {
    rem(dest, lhs, rhs);
  }
}

void MacroAssembler::rotateLeft64(Imm32 count, Register64 src, Register64 java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 19
                                  Register temp) {
  Drol(dest.reg, src.reg, count  
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
MacroAssembler:Registercount java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
,java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 67
  Drol
}

void                                                 BaseIndex addr 
Rol ,count;
}
 input, Register){
  Rol(dest, input, count);
}

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

void MacroAssembler::rotateRight(Imm32 countjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
);
}
void MacroAssembler::rotateRight(Register count (hisjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                                 Register dest) {
  Ror(dest, input, count);
}

void java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 56
  srawjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void MacroAssembler::rshift32Arithmetic(java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 1
  rshift32Arithmetic(imm, dest, dest);
}

voidjava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 64
                                        Register dest) {
  sraiw  .&;
}

void MacroAssembler  storePtr(cratch,dest)
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
}

(Imm32  Register dest){
  rshift32(imm, dest, dest);
}

id MacroAssembler:(Imm32imm,Register, ){
    loadPtraddr,scratch;
}

void MacroAssembler::rshift64Arithmetic(Imm32 imm, java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 55
  MOZ_ASSERT(0  (dest dest )
  srai(dest.reg, dest.reg, imm.value);
}

void MacroAssembler::rshift64Arithmetic(Register shift, Register64 dest) {
( dest.reg, )
 Imm32mask Addresssrc,

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

void MacroAssembler::rshift64(Imm32 imm, Register64 dest)  :InvertConditionc)  ,&kip;
  MOZ_ASSERT(0 <  (skip;
  srli(dest.reg, destvoid:test32MovePtrConditioncond,const Address& addr,
}

void MacroAssembler::rshiftPtrArithmetic(Imm32 imm, Register dest) {
rshiftPtrArithmeticimm,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  MOZ_ASSERT(ond= : |cond= :NonZero;
}

void bjava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 71
                                                 Register srcDest) {
  rshiftPtrArithmetic(shift, srcDest);
}

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

void MacroAssembler:: ma_xor( ,);
  rshiftPtr(imm, dest, dest);
}

void MacroAssembler::rshiftPtr(Imm32 imm, Register src, Register dest)java.lang.StringIndexOutOfBoundsException: Range [0, 71) out of bounds for length 68
  MOZ_ASSERT(0 <= imm.value && imm.java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 25
  srli(dest, src, imm.value);
}

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

:( index ,
                                          java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 26
                                          Label* failure) {
  MOZ_RELEASE_ASSERT(!JitOptions.spectreIndexMasking);
  branch32(Assembler::BelowOrEqual, length, index, failure);
}

void MacroAssembler::spectreBoundsCheck32(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 38
            RegistermaybeScratch
                                          Label* failure) {
  MOZ_RELEASE_ASSERT( xor32(scratch2 dest;
  branch32(}
}
void MacroAssembler::spectreBoundsCheckPtrd.,destreg src.eg);
                                           
                 *java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 60
  MOZ_RELEASE_ASSERT(!JitOptions.spectreIndexMasking);
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
}

void MacroAssembler::spectreBoundsCheckPtr(Register index,
                                           java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
                                           Register maybeScratch,
                                           Label* failure) {
  MacroAssemblerxorPtrImm32imm,Registersrc,Register dest){
  branchPtr(Assembler::BelowOrEqual, length, index, failure);
}
void MacroAssembler::spectreMovePtr(Condition, // ===============================================================
  MOZ_CRASH("spectreMovePtr
}
void MacroAssembler::spectreZeroRegister(Condition cond, Register scratch,
                                         Register dest) {
  MOZ_CRASH("spectreZeroRegister");
}
void MacroAssembler:  // Require: the output is not the same as any of the inputs.
  fsqrt_d(dest, src);
}
void MacroAssembler:sqrtFloat32(loatRegister src,FloatRegisterdest){
  fsqrt_s(dest, src);
}

FaultingCodeOffset MacroAssembler::storeFloat16(FloatRegister src,
                                                 Address&dest,Register){
      sltu(utput,output,lhsLo)  /output  carry from`hsLo +rhsLojava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
}
FaultingCodeOffset     add(output, output;  / output = carry + lhsHi + rhsHi
                                                const BaseIndex& dest,
                                                Register) {
  return ma_storeFloat16(src, dest);
}

FaultingCodeOffset MacroAssembler::storeFloat32(void MacroAssembler::wasmMulI64WideHI64(Register lhs, Register
                                                Address addr java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  return ma_storeFloat(src, addr);
}
FaultingCodeOffset MacroAssembler::storeFloat32(java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 28
                                                
  return ma_storeFloat :( &addr java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
}

FaultingCodeOffset MacroAssembler
                                               &addr java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  return loadPtr(Address(StackPointer, 0), ra);
}
FaultingCodeOffset MacroAssembler::java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 19
                                               const BaseIndex& addr) {
  return ma_storeDouble(src, addr);
}

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

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

void MacroAssembler::sub32(const Address& src, Register dest) {
  UseScratchRegisterScope temps(this);
  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_d(dest, dest, src);
}

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, scratch);
  storePtr(scratch, dest);
}

void MacroAssembler::subPtr(const Address& addr, Register dest) {
  UseScratchRegisterScope temps(this);
  Register scratch = temps.Acquire();
  loadPtr(addr, scratch);
  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, const Address& addr,
                                   Imm32 mask, const Address& src,
                                   Register dest) {
  MOZ_RELEASE_ASSERT(!JitOptions.spectreStringMitigations);
  Label skip;
  branchTest32(Assembler::InvertCondition(cond), addr, mask, &skip);
  loadPtr(src, dest);
  bind(&skip);
}
void MacroAssembler::test32MovePtr(Condition cond, const Address& addr,
                                   Imm32 mask, Register src, Register dest) {
  MOZ_ASSERT(cond == Assembler::Zero || cond == Assembler::NonZero);
  Label skip;
  branchTest32(Assembler::InvertCondition(cond), addr, mask, &skip);
  movePtr(src, dest);
  bind(&skip);
}
void MacroAssembler::test32MovePtr(Condition cond, Register operand, Imm32 mask,
                                   Register src, Register dest) {
  MOZ_ASSERT(cond == Assembler::Zero || cond == Assembler::NonZero);
  Label skip;
  branchTest32(Assembler::InvertCondition(cond), operand, mask, &skip);
  movePtr(src, dest);
  bind(&skip);
}
void MacroAssembler::xor32(Register src, Register dest) {
  xor_(dest, dest, src);
}

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

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

void MacroAssembler::xor32(Imm32 imm, const Address& dest) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  load32(dest, scratch2);
  xor32(imm, scratch2);
  store32(scratch2, dest);
}

void MacroAssembler::xor32(const Address& src, Register dest) {
  UseScratchRegisterScope temps(this);
  Register scratch2 = temps.Acquire();
  load32(src, scratch2);
  xor32(scratch2, dest);
}
void MacroAssembler::xor64(Register64 src, Register64 dest) {
  xor_(dest.reg, dest.reg, src.reg);
}

void MacroAssembler::xor64(Imm64 imm, Register64 dest) {
  ma_xor(dest.reg, dest.reg, imm);
}
void MacroAssembler::xorPtr(Register src, Register dest) {
  xor_(dest, dest, src);
}

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

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

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

void MacroAssembler::wasmAddSubI128HI64(Register lhsLo, Register lhsHi,
                                        Register rhsLo, Register rhsHi,
                                        Register output, bool isAdd) {
  // Require: the output is not the same as any of the inputs.
  MOZ_RELEASE_ASSERT(output != lhsLo && output != lhsHi && output != rhsLo &&
                     output != rhsHi);
  // We use `output` as a temp to hold the carry or borrow.
  if (isAdd) {
    add(output, lhsLo, rhsLo);    // output = lhsLo + rhsLo
    sltu(output, output, lhsLo);  // output = carry from `lhsLo + rhsLo`
    add(output, output, lhsHi);   // output = carry + lhsHi
    add(output, output, rhsHi);   // 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
  }
}

void MacroAssembler::wasmMulI64WideHI64(Register lhs, Register rhs,
                                        Register output, bool isSigned) {
  if (isSigned) {
    mulh(output, lhs, rhs);
  } else {
    mulhu(output, lhs, rhs);
  }
}

//}}} check_macroassembler_style

void MacroAssemblerRiscv64Compat::incrementInt32Value(const Address& addr) {
  asMasm().add32(Imm32(1), addr);
}

void MacroAssemblerRiscv64Compat::retn(Imm32 n) {
  // pc <- [sp]; sp += n
  loadPtr(Address(StackPointer, 0), ra);
  asMasm().addPtr(n, StackPointer);
  jr(ra, 0);
}
}  // namespace jit
}  // namespace js

#endif /* jit_riscv64_MacroAssembler_riscv64_inl_h */