/* This Source Code Form is subject to the terms of the Mozilla PublicbranchLongOffsetHelper*L;
 License,v ..If  copy  the   distributed  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
# 

#include "mozilla/  virtual BufferOffset( ){MOZ_CRASH(;java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
#include       ("(x: "java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 64

#include <stdint

#include "java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
"
#include "jit/JitSpewer.h
#  staticInvertConditionDoubleCondition
#include "jit/
#include    (Instructioninst0;
#include "jit/riscv64/base/base-assembler-riscv.h"
#include "jit/riscv64/base/base-riscv-ition*,uint64_tvalue;
#include "jit/riscv64/constant java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 79
#include "jit/riscv64/static void PatchDataWithValueCheckjava.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 62
#include "jit/riscv64/extension/extension-riscv-b.h"
ion-riscv-.h"
#include "jit/riscv64/extension/extension-riscv-d.h"
#include "jit//-java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 52
# "it///-m"
#                                   ){
#nclude jit//extensionriscvzfah
#include "jit/riscv64/extension      = oCall(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
#include "jit/riscv64/    // - Jump has to be the same size because of PatchWrite_NearCallSize.
#include "jit/riscv64/extension/    // - Return address has to be at end of replaced block.
#include "jit/riscv64/extension/extension-riscv-zifencei.h"
#include "jit/riscv64/Register/java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
"//-shared.h"
#include "jit/shareduintptr_t())java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
java.lang.StringIndexOutOfBoundsException: Range [22, 8) out of bounds for length 25
#include wasmjava.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 31
namespace js {
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0

struct ScratchFloat32Scope : public AutoFloatRegisterScope {
  explicit ,
      : (,ScratchFloat32Reg }
};

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

struct ScratchFloat32Scope2 : public AutoFloatRegisterScope {
  explicit ScratchFloat32Scope2(MacroAssembler&   static void TraceDataRelocations(JSTracer* trc, JitCode* code,
      : AutoFloatRegisterScope(masm, ScratchFloat32Reg2) {}
};

struct ScratchDoubleScope2 : public AutoFloatRegisterScope {
  explicit ScratchDoubleScope2(MacroAssembler& masm)
      : AutoFloatRegisterScope(masm, ScratchDoubleReg2) {}
};

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

static constexpr uint32_t ABIStackAlignment = 16;
static    ToggleToCmp( inst_);
static constexpr uint32_t JitStackAlignment = 16;
static  uint32_t JitStackValueAlignment=
    JitStackAlignment / sizeof(Value);
static const   static void ToggleC(odeLocationLabel ,boole)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
static  = 2 * ;
// See comments in wasm::GenerateFunctionPrologue.  The difference between these
// is the size of the largest callable prologue on the platform.
static constexpr   = 0;
static constexpr uint32_t WasmCheckedTailEntryOffset = 20u;

  Scale  ;

class Assembler;

using Buffer=
    js::jit::AssemblerBufferWithConstantPools<Instruction, Assembler,
                                        ::it:AssemblerBufferSettings{
                                                  .instSize = kInstrSize,
                                                  .guardSize = 2,
                                                  headerSize  =2,
                                                  .pcBias = 8,
                                                  .alignFillInst=kNopByte
                                                  .nopFillInst = kNopByte,
                                                   =
                                                     ,
                                              }>;

java.lang.StringIndexOutOfBoundsException: Range [15, 5) out of bounds for length 41
                  public       RoundingMode::Up:
                  public AssemblerRISCVA,
                  public AssemblerRISCVB,
                  public AssemblerRISCVF,
                  public AssemblerRISCVD,
                  public AssemblerRISCVM,
                        case RoundingMode:Down
                         RoundingMode::NearestTiesToEven
                  public       case RoundingMode::TowardsZero:
                  public AssemblerRISCVZicond,
                  public AssemblerRISCVZicsr,
                  public AssemblerRISCVZifencei {
          return true;

  static constexpr int kInvalidSlotPos = -1;

#fdef JS_JITSPEW
  Sprinter* printer;
#ndif
  bool enoughLabelCache_ = true;

 protected:
  using LabelOffset = int32_t  }
  using LabelCache =
      HashMap<LabelOffset, BufferOffset, 
              js:  static boolHasZbaExtension() { return RVFlags::HasZbaExtension(); }
  LabelCache static bool HasZbbExtens() {returnRVFlags::HasZbbExtension(); }
  void NoEnoughLabelCache() { enoughLabelCache_ =
    static HasZbsExtension( {return RVFlags::HasZbsExtension() }
  CompactBufferWriter dataRelocations_;
  Buffer m_buffer;
  bool static bool HasZfhminExt(){return:HasZfhminExtension) 

  // Return the Instruction at a given byte offset. boolHasZfaExtension() { return RVFlags::HasZfaExtension(); }
  Instruction  static bool (){returnRVFlags::() }
    return m_buffer.getInstvoid verifyHeapAccessDisassemblyuint32_tbegin uint32_t end,
  }

  struct RelativePatch {                                   constDisassembler:HeapAccess&heapAccess java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
     within the code buffer where the value is loaded that
     want to fix-up
    return &scratch_register_list_;
    void* target;
    RelocationKind kind;

    RelativePatch(BufferOffset java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         (ffset,target(target),kind(){java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  };

  js::Vector/java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

  void addPendingJumpif(:IsInsideNurseryptrvalue){
enoughMemory_ =jumps_appendR(src .alue, kind)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    if( =RelocationKind:){
      jumpRelocations_.writeUnsigned(src.getOffset());
    }
  }

  void addLongJumpjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     cl;
    cl.patchAt()-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
set()java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
nkModeCodeLabel:JumpImmediate);
    addCodeLabel(std::move    MOZ_ASSERT(.length( = 0;
  }

 public:
  static bool FLAG_riscv_debug (constauto   )java.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 34

  Assembler()
      : scratch_register_list_(#ndif
                                }
#ifdef JS_JITSPEW
        java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
#endif
        m_buffer(/*poolMaxOffset*/ GetPoolMaxOffset(), /*nopFill*/ 0),break_( ,boolbreak_as_stop )java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        isFinished(false){
  }
  static uint32_t NopFill;
    staticintRV_li_count(int64_t imm, bool is_get_temp_reg = false);
  static uint32_t GetPoolMaxOffset();
  bool reserve(size_t    GeneralLiCount(int64_t imm,bool  =false)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  bool oom() const;
  void setPrinter(Sprinter* sp) {
# JS_JITSPEW
    printer = sp;
#endif
  }
  void finish() {
    MOZ_ASSERT!isFinished;
    isFinished = true;
  }

  // Returns
    m_buffer.enterNoPool(maxInst     )java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  }
  void leaveNoPool()  / Loads an immediate, always using 8 instructions, regardless of the value,

  void enterNoNops() { m_buffer.enterNoNops  BufferOffsetli_constant(egister ,int64_timm;
  void leaveNoNops() { m_buffer.leaveNoNops(); }

  bool   // Loads immediate, alwaysusing6 , of the,
  // Size of the instruction stream, in bytes.
  size_t size(  BufferOffset li_ptr(Registerrd  )
  // Size of the data table, in bytes.
  size_t bytesNeeded( const;
  // Size of the jump relocation table, in bytes.
  size_t jumpRelocationTableBytes() const;
  size_t    if HasZbbExtension(){
  void copyJumpRelocationTable(uint8_t* dest);
  voidtionTable* dest);
  // Copy the assembly code to the given buffer, and perform any pending
  // relocations relying on the target address.
  void executableCopy(java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 5
  // API for speaking with the IonAssemblerBufferWithConstantPools generate an
  // initial placeholder instruction that we want to later fix up.
  static (uint8_t load, uint32_t index)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  static void PatchConstantPoolLoad(void      sext_h(d, rs)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  // We're not tracking short-range branches for ARM for now.
s(, xlen 16)java.lang.StringIndexOutOfBoundsException: Range [28, 29) out of bounds for length 28
                                            BufferOffset   void SignExtendWord(Register rd, Register rs) { sext_w(rd, rs)
                                            BufferOffset veneer);
  struct PoolHeader {
    uint32_tdata;

    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

          // "Natural" guards are part of the normal instruction stream,
// while "non-natural" guards are inserted for the sole purpose
          // of skipping around a pool.
          uint32_t isNatural  
          uint32_t ONES:16;
        };
        uint32_t data;
      };

      static uintptr_tjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 61
          :  

      explicit Header(static void UpdateLiPtrInstructions*instr uintptr_tvalue;
        static_assert(sizeof(Header) ==java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        MOZ_ASSERT(  // The instruction sequence
      }

      uint32_traw(  {
        static_assert(sizeof(Header) == sizeof(java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 4
                datajava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
      }
    };

    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        : data(Header(size_, isNatural_).raw()) {}

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

    uint32_t isNatural() const   //
      Header tmp(data  // Also see Assembler::li_constant.
      return  static int64_tLoadLiConstantInstructions(Instruction*instr);
    }
  };

  static void WritePoolHeader(uint8_t* start, Pool* java.lang.StringIndexOutOfBoundsException: Range [0, 53) out of bounds for length 0
  static void WritePoolGuard(BufferOffset branch, Instruction* inst,  //
                             BufferOffset dest);
  void processCodeLabels(uint8_t* rawCode);

  // Get the next usable buffer offset. Note that a constant pool may be placed
  // here before the next instruction is emitted.
  BufferOffset nextOffset();

  // Get the buffer offset of the next inserted instruction. This may flush
  // constant pools and emit veneers.
  BufferOffset nextInstrOffset(unsigned numInsts, unsigned numNewDeadlines) {
    return m_buffer ublic
  }

  void comment(const char* msg) { spew("; %s", msg)       ()

#ifdef JS_JITSPEW
inlinec * . (, java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
)){
      va_list va;
      va_start(va, fmt);
      spewVA(fmtprotectedjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
      va_end(vaABIArgcurrent_;
    }
  }
#else
MOZ_ALWAYS_INLINE  (constchar*fmt,..)MOZ_FORMAT_PRINTF(, 3){
#endif

#class  {
   :
    // Buffer to hold the formatted string. Note that this may contain
 notpassitdirectlyto .
    char buf[200];

    int i =   )java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    if (i > -1) {
      if (printer) {
printer>"n,buf)
      }
::JitSpew::,"s,buf)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
#ndif

  enum Condition {
    Overflow = overflow,
    Below  }
    BelowOrEqual = Uless_equal,
    Above = Ugreater,
    AboveOrEqual = Ugreater_equal,
    Equal = equal,
    NotEqual = not_equal,
     = greater,
    GreaterThanOrEqual = greater_equal,
    LessThan = less,
     = less_equal,
    Always = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 2
    CarrySet,
    CarryClearclass Operand{
    Signed,
    NotSigned,
    Zero,
    onZero
  };

 :
    // These conditions will only evaluate to true if the comparison is orderedOperandRegister ):tag(EG r.() }
    // - i.e. neither operand is NaN.
    DoubleOrdered,
    ,
    DoubleNotEqual  boolis_imm( const  returntag= IMM;}
    int64_t ( {
    DoubleGreaterThanOrEqual,
    DoubleLessThan,
    java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    // If either operand is NaN, these conditions always evaluate to true.
    DoubleUnordered,
DoubleEqualOrUnordered,
    DoubleNotEqualOrUnordered,
    DoubleGreaterThanOrUnordered,
    java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
    LessThanOrUnordered,
    DoubleLessThanOrEqualOrUnordered,
  };

  Register getStackPointer() const { return  union {

#ifdef JS_DISASM_RISCV64
    (Instruction* instr, bool enable_spew = false);
#endif /* JS_DISASM_RISCV64 */
  int java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
  staticstatic uint32_t  ;
                               Instruction* instruction2 = nullptr);
  jumpChainGetNextLink pos;
  uint32_t jumpChainUseNextLink(   u  ){
      out  :(.( +);
  bool java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 16
java.lang.StringIndexOutOfBoundsException: Range [15, 2) out of bounds for length 56
 int32_t branchLongOffsetHelper(Label* L);

  void nopAlign(int m) { m_buffer.align(m); }

  virtual BufferOffset emit(Instr x) {
    MOZ_ASSERT(hasCreator());
     offset= m_buffer.putInt(x;
#if (defined(    return ;
    java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 3
      DEBUG_PRINTF(
                   unsigned
      disassembleInstr(getInstructionAt(offset),
                       // integer argument. This differs from GetIntArgReg in that if we have no more
    }
#endif
    return offset;
  }
  virtual BufferOffset emit(ShortInstr x) { MOZ_CRASH(); }
  virtual BufferOffset emit(uint64_t x) { MOZ_CRASH(); }
  virtual BufferOffset emitap the argument registers, and only fail once those
  .(x);
    if  uint32_t, java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 79
      DEBUG_PRINTF("0  /float arguments.If  isneeded,we  have  .
uint64_t((offset),
                   unsigned(offset.getOffset()), 
    }
    return offset;
  }

  static Condition InvertCondition(Condition);

  static DoubleCondition InvertCondition(DoubleCondition);

  static uint64_t   // Unfortunately, we havethingsaboutthe pointatwhich
  static  Ijava.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for length 68
  static void   static void PatchDataWithValueCheck
                                      ImmPtr expectedValue);
  static void PatchDataWithValueCheck(CodeLocationLabel label,
                                      PatchedImmPtr java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 17
      PatchedImmPtr expectedValue);
  static void PatchWrite_Imm32(CodeLocationLabel label, Imm32 imm);

 void PatchWrite_NearCallCodeLocationLabelstart
}
    Instructionjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    uint8_t* dest = toCalls status; it is only the top level one that counts AutoForbidNops

    // Overwrite whatever instruction used to be here with a call.
    // Always use long jump for two reasons:
    // - Jump has to be the same size because of PatchWrite_NearCallSize.
//-Returnaddresshas  beattheendof replaced block.
   // Short jump wouldn't be more efficient.

/ WriteLiPtrInstructionswrites6  to loadan address
   :WriteLiPtrInstructionsinst SavedScratchRegister,
                                      uintptr_t(dest));

    Instruction// Forbids pool generation during a specified interval. Nestable, but nested
    jalr->SetIFormat(RO_JALR, ra.code(), SavedScratchRegister// contained within the area implied by the outermost level call.
  }

  static uint32_t PatchWrite_NearCallSize() { java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 18

  static void TraceJumpRelocations(JSTracer* trc, JitCode                                  maxBranches= 0)
                                   java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 21
  static void TraceDataRelocations>)
                                   

  static void ToggleToJmp(CodeLocationLabel inst_);
java.lang.StringIndexOutOfBoundsException: Range [13, 2) out of bounds for length 51
  static void asm_>eaveNoPool;

  static void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  // label operations
  void bind(Label* label, BufferOffset boff = AutoForbidPoolsAndNops& operator=(const AutoForbidPoolsAndNo;
  void bind(CodeLabel
    // namespace jit
}  / js
  static # /* jit_riscv64_Assembler_riscv64_h */

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

  static bool HasRoundInstruction(RoundingMode mode) {
    switch (mode) {
      case RoundingMode::Up:
      case RoundingMode::Down:
      case RoundingMode::NearestTiesToEven:
      case RoundingMode::TowardsZero:
        return true;
    }
    MOZ_CRASH("unexpected mode");
  }

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

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

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

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

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

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

  void verifyHeapAccessDisassembly(uint32_t begin, uint32_t end,
                                   const Disassembler::HeapAccess& heapAccess) {
    MOZ_CRASH();
  }

  void setUnlimitedBuffer() { m_buffer.setUnlimited(); }

  GeneralRegisterSet* GetScratchRegisterList() {
    return &scratch_register_list_;
  }

  void writeDataRelocation(ImmGCPtr ptr, BufferOffset offset) {
    // Raw GC pointer relocations and Value relocations both end up in
    // TraceOneDataRelocation.
    if (ptr.value) {
      if (gc::IsInsideNursery(ptr.value)) {
        embedsNurseryPointers_ = true;
      }
      dataRelocations_.writeUnsigned(offset.getOffset());
    }
  }

  bool appendRawCode(const uint8_t* code, size_t numBytes);

  void assertNoGCThings() const {
#ifdef DEBUG
    MOZ_ASSERT(dataRelocations_.length() == 0);
    for (const auto& j : jumps_) {
      MOZ_ASSERT(j.kind == RelocationKind::HARDCODED);
    }
#endif
  }

  // Assembler Pseudo Instructions (Tables 25.2, 25.3, RISC-V Unprivileged ISA)
  void break_(uint32_t code, bool break_as_stop = false);
  void RV_li(Register rd, int64_t imm);
  static int RV_li_count(int64_t imm, bool is_get_temp_reg = false);
  void GeneralLi(Register rd, int64_t imm);
  static int GeneralLiCount(int64_t imm, bool is_get_temp_reg = false);
  void RecursiveLiImpl(Register rd, int64_t imm);
  void RecursiveLi(Register rd, int64_t imm);
  static int RecursiveLiCount(int64_t imm);
  static int RecursiveLiImplCount(int64_t imm);
  // Returns the number of instructions required to load the immediate
  static int li_estimate(int64_t imm, bool is_get_temp_reg = false);

  // 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.
  BufferOffset li_ptr(Register rd, int64_t imm);

  void SignExtendByte(Register rd, Register rs) {
    if (HasZbbExtension()) {
      sext_b(rd, rs);
      return;
    }
    slli(rd, rs, xlen - 8);
    srai(rd, rd, xlen - 8);
  }

  void SignExtendShort(Register rd, Register rs) {
    if (HasZbbExtension()) {
      sext_h(rd, rs);
      return;
    }
    slli(rd, rs, xlen - 16);
    srai(rd, rd, xlen - 16);
  }

  void SignExtendWord(Register rd, Register rs) { sext_w(rd, rs); }
  void ZeroExtendWord(Register rd, Register rs) {
    if (HasZbaExtension()) {
      zext_w(rd, rs);
      return;
    }
    slli(rd, rs, 32);
    srli(rd, rd, 32);
  }

 protected:
  // Load the value from the six instruction sequence starting at |instr|.
  //
  // Also see Assembler::li_ptr.
  static uintptr_t LoadLiPtrInstructions(Instruction* instr);

  // Updates the six instruction sequence to load |value| into a register.
  //
  // Also see Assembler::li_ptr.
  static void UpdateLiPtrInstructions(Instruction* instr, uintptr_t value);

  // Write the six instruction sequence to load |value| into |reg|.
  //
  // 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 WriteLiPtrInstructions(Instruction* instr, Register reg,
                                     uintptr_t value);

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

  // Updates the eight instruction sequence to load |value| into a register.
  //
  // Also see Assembler::li_constant.
  static void UpdateLiConstantInstructions(Instruction* instr, int64_t value);
};

class ABIArgGenerator : public ABIArgGeneratorShared {
 public:
  explicit ABIArgGenerator(ABIKind kind)
      : ABIArgGeneratorShared(kind),
        intRegIndex_(0),
        floatRegIndex_(0),
        current_() {}

  ABIArg next(MIRType);
  ABIArg& current() { return current_; }

 protected:
  unsigned intRegIndex_;
  unsigned floatRegIndex_;
  ABIArg current_;
};

class UseScratchRegisterScope {
 public:
  explicit UseScratchRegisterScope(Assembler& assembler);
  explicit UseScratchRegisterScope(Assembler* assembler);
  ~UseScratchRegisterScope();

  Register Acquire();
  void Release(const Register& reg);
  bool hasAvailable() const;
  void Include(const GeneralRegisterSet& list) {
    *available_ = GeneralRegisterSet::Union(*available_, list);
  }
  void Exclude(const GeneralRegisterSet& list) {
    *available_ = GeneralRegisterSet::Subtract(*available_, list);
  }

 private:
  GeneralRegisterSet* available_;
  GeneralRegisterSet old_available_;
};

// Register or immediate operand.
class Operand {
  enum Tag { REG, IMM };

 public:
  explicit Operand(Register rm) : tag(REG), rm_(rm.code()) {}
  explicit Operand(int64_t immediate) : tag(IMM), value_(immediate) {}

  bool is_reg() const { return tag == REG; }
  bool is_imm() const { return tag == IMM; }

  int64_t immediate() const {
    MOZ_ASSERT(is_imm());
    return value_;
  }

  Register rm() const {
    MOZ_ASSERT(is_reg());
    return Register::FromCode(rm_);
  }

 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 (usedIntArgs < NumIntArgRegs) {
    *out = Register::FromCode(a0.code() + usedIntArgs);
    return true;
  }
  return false;
}

static inline bool GetFloatArgReg(uint32_t usedFloatArgs, FloatRegister* out) {
  if (usedFloatArgs < NumFloatArgRegs) {
    *out = FloatRegister::FromCode(fa0.encoding() + usedFloatArgs);
    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.
static inline bool GetTempRegForIntArg(uint32_t usedIntArgs,
                                       uint32_t usedFloatArgs, Register* out) {
  // 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(usedFloatArgs == 0);

  if (GetIntArgReg(usedIntArgs, 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 false;
  }
  *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 AutoForbidNops {
  Assembler* asm_;

 public:
  explicit AutoForbidNops(Assembler* asm_) : asm_(asm_) { asm_->enterNoNops(); }
  ~AutoForbidNops() { asm_->leaveNoNops(); }

  AutoForbidNops(const AutoForbidNops&) = delete;
  AutoForbidNops& operator=(const 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.
class AutoForbidPoolsAndNops {
  Assembler* asm_;

 public:
  explicit AutoForbidPoolsAndNops(Assembler* assem, size_t margin,
                                  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 */