Quelle  Assembler-riscv64.h

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

// Copyright (c) 1994-2006 Sun Microsystems Inc.
// All Rights Reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// - Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// - Redistribution in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// - Neither the name of Sun Microsystems or the names of contributors may
// be used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// The original source code covered by the above license above has been
// modified significantly by Google Inc.
// Copyright 2021 the V8 project authors. All rights reserved.

#ifndef jit_riscv64_Assembler_riscv64_h
#define jit_riscv64_Assembler_riscv64_h

#include "mozilla/Assertions              ::ystemAllocPolicy>;
#"/.h"

#include <stdint java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

i jit/.hjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
#include "jit/JitCode.  Instruction*getInstructionAt(ufferOffset ){
#include "jit/JitSpewer.h"
#include "jit/Registers.h"
"jit/egisterSetshjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
chitectureh
#include "jit/riscv64    
#include "jit/riscv64    
#include "BufferOffsetoffset;
#include "    void*target;
#include "jit/riscv64/extension/extension-    elocationKind ;
#nclude "it/extensionextension--.java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
include "jit/iscv64//extension-riscv-d.h"
#include "jit/riscv64/extension/extension-riscv-f.h"
#include "jit/riscv64/extension/extension-riscv-m.h"
#include "jit/java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
#nclude jriscv64extensionzfa"
#include "jit/riscv64/extension/extension-riscv-zfh.h"
#include
#include    addPendingJumpBufferOffsetsrc ImmPtr , kind java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
#-riscvzifencei"
#include "jit/riscv64/Register-riscv64.h"
include jitAssembler."
#include "jit/shared/Disassembler-shared.h"
#include " jumpRelocations_writeUnsigned(rc.etOffset()java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
"js/ashTable.h"
#include "wasm/WasmTypeDeclsCodeLabel ;
espace {
namespace jit {

struct ScratchFloat32Scope.)>(.getOffset();
  explicit (MacroAssembler& masm
      : AutoFloatRegisterScope(masmaddCodeLabelstdm()java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
;

struct ScratchDoubleScope : public java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 0
MacroAssembler& masm)
      : AutoFloatRegisterScope(masm, ScratchDoubleReg) {}
};

struct                                < t6.code))java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  explicit        /poolMaxOffset (,/nopFill/0,
      : AutoFloatRegisterScope(masm, java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 27
};

struct ScratchDoubleScope2 : public AutoFloatRegisterScope {
  java.lang.StringIndexOutOfBoundsException: Range [30, 10) out of bounds for length 52
      : (masm ScratchDoubleReg2){
};

class MacroAssembler;

static constexpr uint32_t ABIStackAlignment = 16;
static constexpr uint32_t CodeAlignment = 16;
static constexpr uint32_t JitStackAlignment = 16;
static constexpr uint32_t JitStackValueAlignment =
    JitStackAlignment / sizeof(Value);
static const uint32_t WasmStackAlignment = 16;
static const uint32_t WasmTrapInstructionLength = 2 * kInstrSize;
// See comments in wasm::GenerateFunctionPrologue.  The difference between these
// is the size of the largest callable prologue on the platform.
static constexpr uint32_t WasmCheckedCallEntryOffset = 0u;
static constexpr uint32_t WasmCheckedTailEntryOffset = 20u;

static const Scale ScalePointer = TimesEight;

class Assembler;

using Buffer =
    js::jit::AssemblerBufferWithConstantPools<Instruction, Assembler,
                                              js::jit::AssemblerBufferSettings{
                             .instSize= kInstrSize,
                                                  .guardSizeoom( ;
                                                   =java.lang.StringIndexOutOfBoundsException: Range [66, 67) out of bounds for length 66
                                                  =8
                                                  java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 22
                                                   = kNopByte,
                          numShortBranchRanges
  leaveNoPool  .(;}
                                              java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

class void({m_bufferleaveNoNops) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
public,
                  public AssemblerRISCVA,
                  public // Size of the instruction stream
                  AssemblerRISCVF,
                  public   // Size of the data table, in
                  public AssemblerRISCVM,
                  public AssemblerRISCVC  
                  public size_t jumpRelocationTableBytesjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
                  void copyJumpRelocationTable(uint8_t* dest);
                  public AssemblerRISCVZicond,
                  public AssemblerRISCVZicsr,
                 AssemblerRISCVZifencei
GeneralRegisterSet ;

    /relocationsrelyingonthetargetaddress

# 
   
#endif
  bool enoughLabelCache_ / initialplaceholderinstructionthat  laterfix .

 protected:
  singLabelOffset=int32_t;
  using LabelCache =
      HashMap<LabelOffset, BufferOffset   voidPatchConstantPoolLoad*,*java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 73
              static void PatchShortRangeBranchToVeneer(Buffer*, unsigned rangeIdx,
L ;
  void NoEnoughLabelCache() { enoughLabelCache_ = false; }
  CompactBufferWriter jumpRelocations_;
  CompactBufferWriter dataRelocations_;
  Buffer m_buffer;
  bool isFinished {

 thegivenoffset
  Instruction
 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19


  struct java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 13
     withinjava.lang.StringIndexOutOfBoundsException: Range [28, 25) out of bounds for length 71
    
    BufferOffset offset;
    void* target;
    RelocationKind kind;

    (ufferOffset,voidtarget RelocationKind )
        : offset(offset), target(target), kind(kind) {}
  };

  ::ectorRelativePatch, 8, SystemAllocPolicy> jumps_;

  void addPendingJump(BufferOffset          
    enoughMemory_          uint32_t isNatural : 1;
    if (kind == RelocationKind::JITCODE) {
      jumpRelocations_.writeUnsigneduint32_tONES: 16;
    }       }
  }

  void addLongJump(BufferOffset src, BufferOffset dst)}java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
    CodeLabel cl;
    cl.patchAt()->bind(src.java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
    cl.target()->bind(dst.getOffset      explicit Header(int32_tdata  data(){
    .setLinkModeCodeLabel:J)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    (:movec));
  }

 publicjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  static bool static_assertsizeofHeader =sizeof();

  Assembler }
      :    }
                               
#JS_JITSPEW
        printer(nullptr),
#ndif
        m_buffer(/*poolMaxOffset*/ GetPoolMaxOffset(), /*nopFill*/ 0),size)constjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
              return tmp.s
  java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  uint32_tuint32_t;
  static uint32_t GetPoolMaxOffset();
B java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  bool /
   (printersp java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
#ifdef  
    printer =   ( {return.nextOffset);}
#endif
  }
  void finish() {
      // Get the buffer  next instruction   
    isFinished = true;
  }

  void enterNoPool(size_t maxInstreturnm_buffernextInstrOffset, );
    }
  }
  void leaveNoPool  void commentconstchar msg  (;%s,msg;}

void  enterNoNops
   spewfmt .java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 66

  bool ;
  // Size of the instruction stream, in bytes.
  size_t  spewVAfmt )
  va_end(va);
  size_t bytesNeeded() const;
      }
  java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 3
 const;
  void copyJumpRelocationTable(uint8_t#
  void
    MOZ_COLD void spewVA(const char* fmt, va_list va) MOZ_FORMAT_PRINTF(2, 0) {
  // relocations relying on the target address.
  void ' ,so  not  it  to  functions.
//APIfor withtheIonAssemblerBufferWithConstantPoolsgeneratean
  // initial placeholder instruction that we want to later fix up.
  java.lang.StringIndexOutOfBoundsException: Range [32, 8) out of bounds for length 64
  static void java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 17
  // We're not tracking short-range branches for ARM for now.
        printer>printf("%s\n", buf);
                                            BufferOffset deadline,
                                            BufferOffset       }
  struct PoolHeader {
    uint32_t data;

    struct Header {
      // The size should take into account the pool header.    }
      // The size is in units of Instruction (4bytes), not byte.
      union {
   struct {
          uint32_t size : 15;

          // "Natural" guards are part of the normal instruction stream, Condition{
          // while "non-natural" guards are inserted for the sole purpose
          // of skipping around a pool.
          uint32_t BelowOrEqual = Uless_equal
uint32_t ONES :16java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        };
        uint32_t data;
      };

      Header(int size_, bool isNatural_    GreaterThan=greater
:size(ize_) () ONES0){java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

LessThanOrEqual ,
             =java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        
      

      uint32_t raw(java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
            // - i..
         ;
      }
    };

    PoolHeader(    DoubleNotEqual
:dataH(,isNatural_.raw() }

    uint32_t size() constjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 29
      Header tmp(data)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
ze
    }

    uint32_t isNatural() const {
      Header tmp();
      return,
    }
  };

  static void DoubleLessThanOrUnorderedjava.lang.StringIndexOutOfBoundsException: Range [30, 31) out of bounds for length 30
  static
  Register getStackPointer) {; }
  voidflushBuffer)}

/java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  // here before the next instruction is emitted.
  BufferOffset  static intdisassembleInstrInstruction*instr,boolenable_spew=false)java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

   jumpChainTargetAt(BufferOffset pos);
  // constant pools and emit veneers.
  BufferOffset nextInstrOffset(unsigned numInsts, unsigned numNewDeadlines) {
    return m_buffer.nextInstrOffset(numInsts, numNewDeadlines);
  }

  void comment(const char* msg                               * instruction2 =nullptr);

#ifdef (Label )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  inline void spew(const char* fmt, ...) MOZ_FORMAT_PRINTF booljumpChainPutTargetAtBufferOffset pos,BufferOffsettarget_pos)
    if MOZ_UNLIKELY(printer | JitSpewEnabled((JitSpew_Codegen)) {
      va_list va;
      va_start(va, fmt);
      spewVA(fmt, va);
      va_end(va);
    }
  }
#else
  MOZ_ALWAYS_INLINE void spew(java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 0
#endif

#ifdef JS_JITSPEW
  MOZ_COLD void spewVA(const char* fmt, va_list va) MOZ_FORMAT_PRINTF(2, 0) {
// Buffer to hold the formattedstring Note  this may 
    // '%' characters, so do not pass it directly to printf functions.
    char buf200;

    int i = VsprintfLiteral(buf, fmt, va BufferOffsetoffset =m_buffer.putInt();
     ( >-1) {
      if (printer) {
        printer-printf("%s\n", buf);
      }
      js::jit::      DEBUG_PRINTF(0x% PRIx64 "%):int64_t(etInstructionAt(offset)),
    }
  }
#endif

  enum      disassembleInstr(etInstructionAt(offset),
    Overflow = overflow,
    Below =               ();
    BelowOrEqual = Uless_equal,
    bove=Ugreaterjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
      java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    Equal  ,
    NotEqual =   virtual BufferOffset(uint64_tx  (;java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    GreaterThan     BufferOffsetoffset=m_buffer.()
    =greater_equal
    LessThan = less      (0%(x java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 64
    LessThanOrEqual =ogetOffset) )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    Always = java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 3
    CarrySet,
    CarryClear,
    Signed,
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    Zero,
    NonZero,
  };

     uint64_tExtractLoad64ValueInstruction*inst0;
  void I* ,uint64_t )java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    // - i.e. neither operand is NaN.
    ImmPtrjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    DoubleEqualjava.lang.StringIndexOutOfBoundsException: Range [38, 16) out of bounds for length 61
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
,
    DoubleGreaterThanOrEqual,
    
    CtoCall java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
/
    DoubleUnordered,
    DoubleEqualOrUnordered*  .(;
        // Overwrite whateveru  here  .
    DoubleGreaterThanOrUnordered,
    
    DoubleLessThanOrUnordered,
DoubleLessThanOrEqualOrUnordered,
  };

  Register getStackPointer() const { return StackPointer; }
  void flushBuffer
     WriteLiPtrInstructions writes 6 instructions to load an address.
  static int disassembleInstr(Instruction* instr, bool java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 65
e/* *
  int jumpChainTargetAt
  staticintjumpChainTargetAt(*instruction,BufferOffsetpos,
Instruction*=;
  BufferOffset jumpChainGetNextLink(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 3
 (*)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
s,  )java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
int32_t(*L )java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
t(abel )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

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

      java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 51
    java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 29
    BufferOffset offset = m_buffer.putInt(x);
#if (defined(DEBUG) || defined(JS_JITSPEW)) && defined(JS_DISASM_RISCV64)
    if (offset.assigned()) {
D(0%  (x:,uint64_tgetInstructionAtoffset),
                   unsigned(offset.getOffset()));
      java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                      ();
      (odeLabel*){label>)>c() java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
e
    return offset;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
virtualBufferOffsetemitShortInstrx){MOZ_CRASH);}
  virtual BufferOffset emit(uint64_t x) { MOZ_CRASH(); }
  uintptr_tGetPointeru*instPtr{
    BufferOffset offset =java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 49
    ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     0""xuint32_t"PRId32\",
                   uint64_t(getInstructionAt(offset mode {
unsigned(ffset.() )
    }
    return offset;
  }

  static Condition  RoundingMode::NearestTiesToEven

  static java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 20

 Instruction inst0;
  static void}
  static void PatchDataWithValueCheckjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ImmPtr);
  static void PatchDataWithValueCheck(CodeLocationLabel label,
                                     PatchedImmPtr newValue,
                                      PatchedImmPtr )java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  static voidPatchWrite_Imm32(CodeLocationLabel label, Imm32 imm);

  static void PatchWrite_NearCall(CodeLocationLabel start,
                                  CodeLocationLabel toCall) {
      static boolHasZfaExtension() { return RVFlags::HasZfaExtension(); }
    uint8_t* dest = toCall.

    // Overwrite whatever instruction used to be here with a call.
    // Always use long jump for two reasons:
// -Jumphas to bethe same sizebecause of PatchWrite_NearCallSize.
    // - Return address has to be at the end of replaced block.
    // Short jump wouldn't be more efficient.

    // WriteLiPtrInstructions writes 6 instructions to load an address.
    Assembler:WriteLiPtrInstructions(inst, SavedScratchRegister,
                                      uintptr_t(dest));

    Instruction* jalr = (instvoidsetUnlimitedBuffer(){m_buffersetUnlimited) }
  *(){
  }

java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

  static void TraceJumpRelocations
                                   java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 20
        da..)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                                   &)

voidjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 51
  staticvoid ToggleToCmp(odeLocationLabelinst_;
 static ToggleCall(odeLocationLabel inst_, bool enable);

  static void Bind(uint8_t* rawCode, const CodeLabel& label);
java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 21
  void bind(Label*       MOZ_ASSERT(j.kindRelocationKind:HARDCODED;
  void bind(CodeLabel* label) { label->java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 5
  uint32_t currentOffset/java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  void retarget(Labelvoid (uint32_t code, bool break_as_stop = false);
   uint32_t NopSize(){ return kInstrSize }

static  GetPointer(int8_t*instPtr){
    Instruction* inst = Instruction::At(instPtr);
return ::ExtractLoad64Value(inst);
  }

  static bool   void RecursiveLiImplRegister ,int64_timm)
    switch (mode) {
      case RoundingMode::Up:
      case::Down:
      case RoundingMode  staticint RecursiveLiImplCountint64_t imm)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
      case RoundingMode::TowardsZero:
        return;
    }
    MOZ_CRASH("unexpected mode" // Loads an immediate, always using 8 instructions, regardless of the value,
  }

  static bool HasZbaExtension(  BufferOffset (Registerrd,int64_timm;

  static bool HasZbbExtension(){return ::HasZbbExtension(); }

  static bool HasZbsExtension() { return RVFlags::HasZbsExtension(); }

  static bool HasZfhminExtension  BufferOffset li_ptr(egister  imm)

  static bool if (HasZbbExtensionjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

  static bool     slli(rd, rs, xlen -rd ,xlen-;

  void verifyHeapAccessDisassembly(srair,rd   )
                                   const java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 0
    MOZ_CRASHif (asZbbExtension(){
  }

  void setUnlimitedBufferjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 21

      sllird,rs -16;
    return &scratch_register_list_;
  }

  void writeDataRelocationjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   / Raw GC pointer relocations and Value relocations both end up in
    // TraceOneDataRelocation.
    if(.alue java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
      if (c:sInsideNurseryptrvalue) {
        embedsNurseryPointers_ = true;
      }
      dataRelocations_. zext_w(rd,rs)
    }
  }

appendRawCode * ;

  gs)const
#ifdef DEBUG
    MOZ_ASSERT
     protected
MOZ_ASSERT(jkind= ::ARDCODED)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    }
#endif
  }

  // Assembler Pseudo Instructions (Tables 25.2, 25.3, RISC-V Unprivileged ISA)
  java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  void RV_li(java.lang.StringIndexOutOfBoundsException: Range [32, 23) out of bounds for length 32
, bool is_get_temp_reg =false);
  void GeneralLi(Register rd, int64_t imm);
  static/  the  nstruction sequence to  ||into|eg|
  void RecursiveLiImpl/java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  void RecursiveLi(  // immediate or a sequence of six nop instructions.
  static int/
  static int java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 32
 ofinstructions requiredtoload the immediate
  static int li_estimate(int64_t imm,                                      uintptr_tvalue);

  // Loads an immediate, always using 8 instructions, regardless of the value,
  // so that it can be modified later.
  BufferOffset li_constant(Register rd, int64_t imm);

  // Loads an immediate, always using 6 instructions, regardless of the value,
  // so that it can be modified later.
    staticint64_t LoadLiConstantInstructions(nstruction instr;

  / Updates the eight instruction sequence to load |value| into a register.
    if (HasZbbExtension()) {
      sext_b
      return;
    }
    slli(rd, rs, xlen - 8);
    srai(rd, rd, xlen - 8);
  }

   public:
    if (HasZbbExtension()) {
      sext_h(rd, rs);
      return;
    }
       java.lang.StringIndexOutOfBoundsException: Range [23, 20) out of bounds for length 24
    srai(rd, rd,       current_() }
  }

  void SignExtendWord(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   ZeroExtendWordRegisterrd Register rs) {
    if (HasZbaExtension()) {
      zext_w(rd, rs);
      return;
    }
    slli(rd, rs, 32);
    (rd, d 32;
  }

 protected:
  // Load the value from the six instruction sequence starting at |instr|.java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
  //
  // Also see Assembler::li_ptr.
staticuintptr_t( )

/     sequencetoload||intoregister
  //
  // Also see Assembler::li_ptr.
  static   Register Ac(;

  // Write the six instruction sequence to load |value| into |reg|.
  //
  // The instruction sequence at |instr| must either be an existing li_ptr(const
  // immediate or a sequence of six nop instructions.
  //
/java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  (Instruction instr reg
                                     uintptr_t value);

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  //
  // Also see Assembler::li_constant.
  java.lang.StringIndexOutOfBoundsException: Range [16, 8) out of bounds for length 64

  // Updates the eight instruction sequence to load |value| into a register.old_available_;
  //
  // Also see Assembler::li_constant.
  
};

class ABIArgGenerator// Register or immediate operand.
 :
  explicit   enum Tag { REGIMM}
      : ABIArgGeneratorShared(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 8
        intRegIndex_0,
        floatRegIndex_(0),
        (){}

  ABIArg next(MIRTypeboolis_reg(  {return tag =REG java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  ABIArg current( { return current_;}

 protected:
  unsigned intRegIndex_(const{
  unsigned floatRegIndex_;
  ABIArg current_;
};

class UseScratchRegisterScope {
 public:
explicit (Assembler&assembler)java.lang.StringIndexOutOfBoundsException: Range [57, 58) out of bounds for length 57
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
~UseScratchRegisterScope();

  Register Acquire();
voidRelease(onst Register®)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 boolhasAvailable()const;
  void Include(const GeneralRegisterSet& list) {
    *available_   }
  }
  void Exclude(const java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
able_=GeneralRegisterSet:Subtract*available_ list);
  }

 private:    uint32_t ;   /  iftag= REG
et available_;
  GeneralRegisterSet old_available_;
};

// Register or immediate operand.
class Operand
  const  ;

 public:
  staticconstuint32_tNumFloatArgRegs ;
  explicit Operand(int64_t immediate) : tag(IMM)static  boolGetIntArgReguint32_t usedIntArgs *out){

 ) rtag ;
  bool returnjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

   immediate)constjava.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
    MOZ_ASSERT(is_imm());
    ;
}

  Register;
    MOZ_ASSERT(is_reg())}
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  }

 private:
  Tag tag;
  union {
    uint32_t rm_;    // valid if tag == REG
    int64_t value_;  // valid if tag == IMM
  };
};

static const uint32_t NumIntArgRegs = 8;
static const uint32_t NumFloatArgRegs = 8;
static inline bool GetIntArgReg(uint32_t usedIntArgs, Register* out) {
  if (static inline bool GetTempRegForIntArg(int32_t usedIntArgs,
    *out = Register::FromCode(a0.code() +                                        uint32_t usedFloatArgs, Register* out) {
    return true;
  }
  return false;
}

 inlinebool ,* java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
    //java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 78
    *out = java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 18
    return true;
  }
  return false;
}

// Get a register in which we plan to put a quantity that will be used as an
// integer argument. This differs from GetIntArgReg in that if we have no more
// actual argument registers to use we will fall back on using whatever
// CallTempReg* don't overlap the argument registers, and only fail once those
// run out too.
inline(usedIntArgs
                                       uint32_t usedFloatArgs, Register*Assembler asm_java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  // NOTE: We can't properly determine which regs are used if there areAutoForbidNops  >(); }
  // float arguments. If this is needed, we will have to guess.
M(usedFloatArgs = 0)

  if(( out){
    return true;
  }
  // Unfortunately, we have to assume things about the point at which
  // GetIntArgReg returns false, because we need to know how many registers it
  // can allocate.
  usedIntArgs -= NumIntArgRegs;
  if (usedIntArgs >= NumCallTempNonArgRegs) {
    return;
  }
  *out = CallTempNonArgRegs[usedIntArgs];
  true
}

// Forbids nop filling for testing purposes. Nestable, but nested calls have
// no effect on the no-nops status; it is only the top level one that counts.
class AutoForbidNops {
  Assembler* asm_;

 public:
  explicit AutoForbidNops(Assembler* asm_) : asm_(asm_) { asm_->enterNoNops()       a java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
AutoForbidNops){ asm_>( }

  AutoForbidNops(const AutoForbidNops>(;
 operatorc AutoForbidNops&) = delete;
};

// Forbids pool generation during a specified interval. Nestable, but nested
// calls must imply a no-pool area of the assembler buffer that is completely
// contained within the area implied by the outermost level call.
{
  Assembler* asm_;

 public/ js
  explicit AutoForbidPoolsAndNops(  marginjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                                  size_t maxBranches = 0)
      : asm_(assem) {
    asm_->enterNoPool(margin, maxBranches);
    asm_->enterNoNops();
  }
  ~AutoForbidPoolsAndNops() {
    asm_->leaveNoNops();
    asm_->leaveNoPool();
  }

  AutoForbidPoolsAndNops(const AutoForbidPoolsAndNops&) = delete;
  AutoForbidPoolsAndNops& operator=(const AutoForbidPoolsAndNops&) = delete;
};

}  // namespace jit
}  // namespace js
#endif /* jit_riscv64_Assembler_riscv64_h */