/* 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/. */

// 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.h"
#include "mozilla/Sprintf.h"

#include <stdint.h>

#include "jit/CompactBuffer.h"
#include "jit/JitCode.h"
#include "jit/JitSpewer.h"
#include "jit/Registers.h"
#include "jit/RegisterSets.h"
#include "jit/riscv64/Architecture-riscv64.h"
#include "jit/riscv64/base/base-assembler-riscv.h"
#include "jit/riscv64/base/base-riscv-i.h"
#include "jit/riscv64/constant/Constant-riscv64.h"
#include "jit/riscv64/extension/extension-riscv-a.h"
#include "jit/riscv64/extension/extension-riscv-b.h"
#include "jit/riscv64/extension/extension-riscv-c.h"
#include "jit/riscv64/extension/extension-riscv-d.h"
#include "jit/riscv64/extension/extension-riscv-f.h"
#include "jit/riscv64/extension/extension-riscv-m.h"
#include "jit/riscv64/extension/extension-riscv-v.h"
#include "jit/riscv64/extension/extension-riscv-zfa.h"
#include "jit/riscv64/extension/extension-riscv-zfh.h"
#include "jit/riscv64/extension/extension-riscv-zicond.h"
#include "jit/riscv64/extension/extension-riscv-zicsr.h"
#include "jit/riscv64/extension/extension-riscv-zifencei.h"
#include "jit/riscv64/Register-riscv64.h"
#include "jit/shared/Assembler-shared.h"
#include "jit/shared/Disassembler-shared.h"
#include "jit/shared/IonAssemblerBufferWithConstantPools.h"
#include "js/HashTable.h"
#include "wasm/WasmTypeDecls.h"
namespace js {
namespace jit {

struct ScratchFloat32Scope : public AutoFloatRegisterScope {
  explicit ScratchFloat32Scope(MacroAssembler& masm)
      : AutoFloatRegisterScope(masm, ScratchFloat32Reg) {}
};

struct ScratchDoubleScope : public AutoFloatRegisterScope {
  explicit ScratchDoubleScope(MacroAssembler& masm)
      : AutoFloatRegisterScope(masm, ScratchDoubleReg) {}
};

struct ScratchFloat32Scope2 : public AutoFloatRegisterScope {
  explicit ScratchFloat32Scope2(MacroAssembler& masm)
      : AutoFloatRegisterScope(masm, ScratchFloat32Reg2) {}
};

struct ScratchDoubleScope2 : public AutoFloatRegisterScope {
  explicit ScratchDoubleScope2(MacroAssembler& masm)
      : AutoFloatRegisterScope(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,
                                                  .guardSize = 2,
                                                  .headerSize = 2,
                                                  .pcBias = 8,
                                                  .alignFillInst = kNopByte,
                                                  .nopFillInst = kNopByte,
                                                  .numShortBranchRanges =
                                                      NumShortBranchRangeTypes,
                                              }>;

class Assembler : public AssemblerShared,
                  public AssemblerRISCVI,
                  public AssemblerRISCVA,
                  public AssemblerRISCVB,
                  public AssemblerRISCVF,
                  public AssemblerRISCVD,
                  public AssemblerRISCVM,
                  public AssemblerRISCVC,
                  public AssemblerRISCVZfa,
                  public AssemblerRISCVZfh,
                  public AssemblerRISCVZicond,
                  public AssemblerRISCVZicsr,
                  public AssemblerRISCVZifencei {
  GeneralRegisterSet scratch_register_list_;

  static constexprintkInvalidSlotPos =-1

# * file You can java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 0
  Sprinter* printer;
#endif
  bool /// - Neither the name of Sun Microsystems or the names of contributors may

 // specific prior written// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  using // THE IMPLIED WARRANTIES. IN NO EVENT// CONTRIBUTORS BE// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  using LabelCache =
      // Copyright 2021 the java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
              js:;
  LabelCache label_cache_;#include mozillaSprintf
  void NoEnoughLabelCache() { enoughLabelCache_ = false; }
  CompactBufferWriter jumpRelocations_;
  CompactBufferWriter dataRelocations_;
  Buffer m_buffer;
#nclude "CompactBufferh"

  // Return the Instruction at a given byte offset.
  Instruction ( offset java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    #include /."
  }

  struct #include "jit/riscv64/Ar-riscv64."
// the offset within the code buffer where the value is loaded that
    // we want to fix-up
     offset
     java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
Rkind

    i"itriscv64/xtension/riscv-c.h"
        : offset(offset), target(target# "jit/iscv64extension/riscvjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  };

  js::Vector<RelativePatch, include"it//extension/-riscv-zfa.hjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

voidaddPendingJump( , ImmPtr target,RelocationKind){
    enoughMemory_ &= jumps_.include "jit/riscv64/extension/extension-.hjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    #"/shared/-shared.hjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
     .s.);
    }
  }

  void #include H.h"
    cl
nam js java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    cltarget(->binddstgetOffset())
    cl  explicitScratchFloat32ScopeMacroAssembler)
    (::ovecl);
  }

 public:
  }java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  Assembler()
      :   explicit ScratchDoubleScope(java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 51
                               (1 <<t6(),
#ifdef JS_JITSPEW
        printer(nullptr),
#endif
m_buffer(**/GetPoolMaxOffset) ** 0)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
        isFinished(false) {
  }
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  static explicit ScratchDoubleScope2(MacroAssembler& masm)
  static  AutoFloatRegisterScope, ScratchDoubleReg2 }
  bool reserve(                     . ,
  bool oom()const
  void setPrinter(Sprinter* sp.headerSize 2,
#ifdef JS_JITSPEW
    printer = sp;
#endif
  }
   .pcBias ,
    MOZ_ASSERT(!isFinished);
    isFinished = true;
  }

  void enterNoPool(size_t maxInst, size_t.nopFillInst
    m_buffer.enterNoPool. =
  }
void (){m_buffer.eaveNoPool) }

  void enterNoNops() { m_buffer.enterNoNops(); }
   leaveNoNops(  .(;}

  bool swapBuffer(wasm::Bytes                   AssemblerRISCVI
  , in bytes.
  size_t size() constpublic 
 bytes.
  size_t bytesNeeded()                  AssemblerRISCVM
  // Size of the jump relocation table, in bytes.
  () const;
  size_t dataRelocationTableBytes() const;
  java.lang.StringIndexOutOfBoundsException: Range [30, 6) out of bounds for length 46
  void  public  {
  GeneralRegisterSet scratch_register_list_
/ relocations  on   .
#fdef JS_JITSPEW
 // API for speaking with the IonAssemblerBufferWithConstantPools generate an
  /initial placeholder instruction wewant to  fixup
  u LabelOffset =int32_tjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
static (void*loadAddr void constPoolAddr);
  // We're not tracking short-range branches for ARM for now.
  java.lang.StringIndexOutOfBoundsException: Range [37, 8) out of bounds for length 71
                                            BufferOffset deadline  abelCachelabel_cache_java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
                                            java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 39
  struct PoolHeader {
      // Returnthe Instruction at a  byte .

    struct Header {
      // The size should take into account the pool header.
      // The size is in units of Instruction (4bytes), not byte.
      union {
        struct {
          // the offset the code buffer where the value// we want to fix-up

RelativePatchB offset * ,RelocationKindkindjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
jsV<java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 57
// of skipping around a pool.
java.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 33
            ;
       }
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     ;

      Header(int size_, bool isNatural_)
          : size(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 17

       Header( ): datadata 
        static_assert(sizeofcl(odeLabel::umpImmediate;
        MOZ_ASSERT(ONESaddCodeLabelstd:(l);
      }

      uint32_t raw() const {
        (()= sizeofuint32_t)
        return data;
      }
    ;

    PoolHeader(int size_ifdef JS_JITSPEW
        : data(#

    uint32_t size( const {
      Header tmp(data);
ize;
    }

    uint32_t isNatural() const {
      Header tmp(data);
      return tmp.isNatural;
    }
  };

  static  static  AsmPoolMaxOffsetjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  static void WritePoolGuard(BufferOffset branch, Instruction* inst,
                             ufferOffsetdest);
  void processCodeLabels(uint8_t* rawCode);

  / Get the next usable buffer offset. Note that a constant pool may be placedvoidsetPrinter(* sp){
  // here before the next instruction is emitted.
BufferOffsetnextOffset( const{  m_buffer(); java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

 offsetofthe  inserted.Thismayflush
  // constant pools and emit veneers.
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 3
    return .(numInsts numNewDeadlines;
  }

  void (const *msg){spew" s" ) 

#ifdef  enterNoNops() { m_buffer.(); }
  inlinevoid spew(const char* fmt,... MOZ_FORMAT_PRINTF(2, 3) {
    if (MOZ_UNLIKELY(printer 
      va_list va
java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 24
     (,va;
      java.lang.StringIndexOutOfBoundsException: Range [17, 12) out of bounds for length 17
    }
  }
#else
  MOZ_ALWAYS_INLINE void spew(  size_t dataRelocationTableBytes()
#ndif

 JS_JITSPEW
java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    // Buffer to hold the formatted string. Note that this may contain
''characters dopassdirectlyprintffunctions
    char   API  speaking  IonAssemblerBufferWithConstantPools  an

    int i = static void InsertIndexIntoTag(uint8_t* load, uint32_t index);
    if (i > -1) {
      if (printer  
        -java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 37
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 18
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
#     java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 16

  enum java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    Overflow = overflow,
    Below = Uless,
    ,
    Above =           ;
    AboveOrEqual = Ugreater_equal,
    ;
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
    GreaterThan  ,
    GreaterThanOrEqual = greater_equal           (ize_, isNaturalisNatural_,(xffff }
    LessThan = less,
     =less_equal
Always  cc_always,
    CarrySet,
    CarryClear,
    Signed,
    NotSigned,
    Zero}
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
  };

  enum DoubleCondition {
    // These conditions will only evaluate to true if the comparison is ordered
    .e. neither operand is NaN
    DoubleOrdered        return data
    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 6
    ,
             data(eadersize_ ).raw(){java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    DoubleGreaterThanOrEqual,
    DoubleLessThan,
    DoubleLessThanOrEqual,
    // If either operand is NaN, these conditions always evaluate to true.Headertmp;
          return tmp.si;
    java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
    DoubleNotEqualOrUnorderedtmpdata);
    DoubleGreaterThanOrUnordered,
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 4
    ,
    DoubleLessThanOrEqualOrUnordered,
  };

()const return StackPointer}
  void (){
#ifdef   / Get the next usable buffer offset. Note that a constant pool may be placed
static  (*instr    ;
#endif /* JS_DISASM_RISCV64 */
int java.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 42
      java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 63
Instruction java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 68
  
  uint32_tjumpChainUseNextLink*label;
  // Returns true if the target was successfully assembled and spewed.
  jumpChainPutTargetAt(ufferOffsetpos  ;
  int32_t branchOffsetHelper(Label* L, if(|)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 5

  void nopAlign(int java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 6

  virtual BufferOffset     / Buffer to hold the formatted string. Note that this may containhold .Notethat  contain
    MOZ_ASSERT []java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    =(;
#if ifi {
    if (offset>java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 37
""(x:", gjava.lang.StringIndexOutOfBoundsException: Range [76, 66) out of bounds for length 76
                   unsigned(offset.getOffset()));
(java.lang.StringIndexOutOfBoundsException: Range [48, 49) out of bounds for length 48
         JitSpewEnabledJitSpew_Codegen)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    A  ,
#endif
    return offset;
}
  virtual BufferOffset emit(    Equal =equal,
 emit(uint64_t ){MOZ_CRASH) }
  virtual BufferOffset emit(uint32_t x) {
   m_bufferputIntx;
    if (GreaterThanOrEqual =,
DEBUG_PRINTF"x" PRIx64 "%x):uint32_t: %" PRId32 "\n",
                   uint64_t(getInstructionAt(offset)),
                   unsigned(ffset.(),x;
    }
    return offset;
  }

  static Condition InvertCondition(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 13

  static DoubleCondition java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 9

static uint64_t (Instruction*)
  static UpdateLoad64Value(nstruction inst0 value;
  static void PatchDataWithValueCheckjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                                       expectedValue);
  static void PatchDataWithValueCheck(CodeLocationLabel label,
                                      PatchedImmPtr newValue,
    DoubleNotEqual,
  static void PatchWrite_Imm32(CodeLocationLabel    DoubleGreaterThan,

  DoubleLessThan,
                                  odeLocationLabel toCall){
    Instruction* inst =    // If either operand is NaN, these conditions always evaluate to true.
    uint8_t dest=toCall.aw);

 instruction sedto be here withacall
    // Always use long jump for two reasons:
    // - Jump has to be the same size because of PatchWrite_NearCallSize.DoubleGreaterThanOrEqualOrUnordered,
    DoubleLessThanOrEqualOrUnordered
    // Short jump wouldn't be more efficient.

//java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
    Assembler::WriteLiPtrInstructions(inst, SavedScratchRegister,
                                      uintptr_t(#ndif *JS_DISASM_RISCV64/

    Instruction    jumpChainTargetAtInstruction instruction, pos,
    jalr-                                instruction2  nullptr)
  }

  static uint32_t PatchWrite_NearCallSize() { return 7 *  uint32_t jumpChainUseNextLinkLabel label;

  static void TraceJumpRelocations(  bool jumpChainPutTargetAt(BufferOffset poBufferOffsettarget_pos;
                                   CompactBufferReader   branchOffsetHelperLabel , OffsetSize bits;
    int32_ branchLongOffsetHelperLabel* L;
                                   CompactBufferReader& reader);

  static void ToggleToJmp(CodeLocationLabel inst_);
staticvoidToggleToCmp(CodeLocationLabel inst_);
  static void ToggleCallMOZ_ASSERT(hasCreator());

      EBUG_PRINTF"x"PRIx64"%)" (etInstructionAt()java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  // label operations
  void bind(Label*  JitSpewEnabledJitSpew_Codegen)
  void bindCodeLabel*label  -target(-bind(urrentOffset);}
  uint32_t currentOffset() #ndif
  void retarget }
  static uint32_t NopSize() {    ( )  ();java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

static  GetPointer(int8_t ) java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    Instruction* inst = Instruction::At(instPtr);
    return Assembler::ExtractLoad64Value(inst);
  }

  static bool HasRoundInstruction(RoundingMode mode      DEBUG_PRINTF("x% PRIx64 (%): : %  "n,
    switch() {
      case                   offset.etOffset),x)
      casejava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 3
      case:
      case RoundingMode:
        return true;
    }
    MOZ_CRASH("  static uint64_tExtractLoad64Value(* inst0)
  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

  static bool HasZbaExtension() { return                                        expectedValue;

   PatchedImmPtr

  static bool                                      PatchedImmPtr expectedValue;

  static bool HasZfhminExtension() java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 67

 java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 70

  static

      -    java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 73
                                   const Disassembler::HeapAccess& heapAccess) {
    MOZ_CRASH:java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 65
  }

   setUnlimitedBuffer  m_buffer.(;}

GeneralRegisterSet GetScratchRegisterList java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    return &scratch_register_list_;
  }

  void writeDataRelocation(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
    // Raw GC pointer relocations and Value relocations both end up in
    // TraceOneDataRelocation.
    if (ptr.value) {
      if (gc::IsInsideNursery(ptr.value)) {
        embedsNurseryPointers_ = true;
      }
taRelocations_writeUnsigned(offsetgetOffset();
    }
  }

  bool appendRawCode(const uint8_t* codeCompactBufferReader reader;

  void   static  ToggleToJmp(CodeLocationLabel inst_);
#ifdef    ( )
      voidCjava.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 63
    for (const auto& j    for (const auto& j 
 == :)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    }
#endif
  }

  / Assembler Pseudo Instructions (Tables 25.2, 25.3, RISC-V Unprivileged ISA)
  break_java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 57
  void staticNopSize) ;}
  uintptr_tu  java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
      Assembler(inst
  static
 (rd  )
  void RecursiveLi(Register rd, java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 19
  static  RoundingMode:
  static int ( ;
  // Returns the number of instructions required to load the immediate
  static int true

 // Loads an immediate, always using 8 instructions, regardless of the value,
  // so that it can be modified later.
li_constant   )

  // Loads an immediate, always using 6 instructions, regardless of the value,  RVFlagsjava.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 70
  // so that it can be modified later.
   R rd,int64_t imm;

  void
    ()) {
      sext_b(rd, rs);
      return;
    }
    slli(,rs xlen -8)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   srai(d ,xlen -8;
  }

  void SignExtendShort(Register rd, Register rs) {
    ifH) java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
      sext_h(rd, rs);
      return;
    }
    ( ,xlen  16)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    srai(rd, java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 3
  }

  void SignExtendWord /java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  void ZeroExtendWord(Register     ptrv){
    if (      ifg:I(.)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      zext_w( )
      return;
    }
    slli(rd, rs  bool (constuint8_t code, size_t numBytes)
    srli(rd,   void assertNoGCThin(  {
  }

 :
      . =RelocationKind:);
  //
  // Also see Assembler::li_ptr.
  static uintptr_t  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  void break_(uint32_t code, bool break_as_stop = false);
  //
  // Also see Assembler::li_ptr.
  static void   static int RV_li_count(int64_t imm  )java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68

  /Writethesixisequenceto loadvalue  ||
  //
  / The instruction sequence at |instr| must either be an existing li_ptr
// immediate or a sequence of six nop instructions.
  /
  // Also see Assembler::li_ptr.
  static void   // Returns the number     
                                      )java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

  // Load the value from the eight instruction sequence starting at |instr|.
  //
  // Also see Assembler::li_constant.
 (*)

/java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  //
  // Also see Assembler::li_constant.
  static java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 5
};

class
publicjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  explicit return
:ABIArgGeneratorShared(kind),
        intRegIndex_(0),
        floatRegIndex_(0),
(){java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

  ABIArg next(void( ,java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 49
  ABIArgjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 srlirdr, )
  unsigned java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
  unsigned floatRegIndex_;
  ABIArg current_;
};

class UseScratchRegisterScope {
 public:
  explicit UseScratchRegisterScope(   uintptr_t LoadLiPtrInstructionsInstruction*instr;
  explicit  /Updatesthesixinstruction to  |alue into a .
  ~  // Also see Assembler::li_p

quire)java.lang.StringIndexOutOfBoundsException: Range [21, 22) out of bounds for length 21
  void Release(const Register& reg);
  bool hasAvailable) ;
  void Include(const GeneralRegisterSet& list
    *available_ =   / Also see Assembler::li_ptr.
  }
  void Exclude(const static void WriteLiPtrInstructions* ,Register ,
    *available_ = GeneralRegisterSet::Subtract(*available_, list);
  }

 private:
  static int64_t LoadLiConstantInstructions(Instruction* instr);
  GeneralRegisterSet java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

// Register or immediate operand.
public
,  ;

 public:
  explicit Operand(Register         (0),
  explicit Operand(current_)}

   )const  tag= ;}
  bool is_imm() const { return tag == IMM¤t({return ;}

  int64_t immediate) const java.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
    MOZ_ASSERT(is_imm()java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return  UseScratchRegisterScope ;
  }

  Register rm()   java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 29
    MOZ_ASSERT   c  ;
    return Register::FromCode(rm_  ()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 private:
  Tag     *avail  :(,;
  union {
rm_ / valid  =REG
    int64_t value_* java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  };
};

atic  uint32_tNumIntArgRegs =8java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
static    =8java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
inline  ( ,Register ){
  if (usedIntArgs
    *out _ bool is_reg( const{ eturn  ==REG }
     true;
  }
  return false;
}

int64_t immediate( const {
  if (usedFloatArgs < NumFloatArgRegs) {
    *out = return value_
  
  }
  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.
ujava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
java.lang.StringIndexOutOfBoundsException: Range [47, 39) out of bounds for length 79
  // NOTE: We can't properly determine which regs are used if there are
  // float arguments. If this is needed, we will have to guess.
  MOZ_ASSERT(java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 3

  static GetFloatArgReg(uint32_t usedFloatArgs FloatRegister*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 -= java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 16
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return // integer argument. This differs from GetIntArgReg in// actual argument registers to use we will fall back on using whatever
  }
  *out = CallTempNonArgRegs[usedIntArgs];
  return 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 AutoForbidNopsstatic  bool GetTempRegForIntArg(int32_t ,
 * asm_;

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

    OZ_ASSERTusedFloatArgs =0)
  AutoForbidNops (etIntArgRegusedIntArgs,))java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
};

// 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.
class AutoForbidPoolsAndNops falsejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  return ;

 publicjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  explicit // no effect on the no-nops status; it is only java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 22
                                  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
      :asm_(ssem){
    asm_->enterNoPool(margin, maxBranches);
    asm_->enterNoNops();
  }  ~( -leaveNoNops(;}
  ~AutoForbidPoolsAndNops() {
    asm_-leaveNoNops(;
    asm_->  AutoForbidNops&=(onstjava.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 60
  }

  AutoForbidPoolsAndNops(const // calls must imply a no-pool area of the assembler buffer that is completely
  AutoForbidPoolsAndNops& operator=(const AutoForbidPoolsAndNops&) = deleteclass AutoForbidPoolsAndNops {
};

}  // namespace jit
}  / namespace js
#endif /* jit_riscv64_Assembler_riscv64_h */Assembler*assem,size_t margin,