* c 19992020 java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 79
* ,Red.Allreserved
 * Copyright (c) 2020, 2022, Huawei Technologies Co., Ltd. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this *DO NOT ALTER OR COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 *
 *
*Please  Oracle, 500OracleParkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

#ncludeprecompiled.hpp"
#include "asm/assembler.hpp"
#include "c1/c1_CodeStubs.hpp"
#include "c1/c1_Defs.hpp"
#include "c1/c1_MacroAssembler.hpp"
#nclude"c1/c1_Runtime1.hpp"
#include "compiler/disassembler.hpp"
#include "compiler/oopMap.hpp"
#include "gc/shared/cardTable.hpp"
#include "gc/shared/java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 2
#include "interpreter/interpreter.hpp"
#include "memory/universe.hpp"
#include "nativeInst_riscv.hpp"
#include "oops/compiledICHolder.hpp"
#include "oops/oop.inline.hpp"
#include "prims/jvmtiExport.hpp"
#include "register_riscv.hpp"
#include "runtime/sharedRuntime.hpp"
#include "runtime/signature.hpp"
#include "runtime/stubRoutines.hpp"
#include "runtime/vframe.hpp"
#include "runtime/vframeArray.hpp"
#include "utilities/powerOfTwo.hpp"
#include "vmreg_riscv.inline.hpp"


// Implementation of StubAssembler

int StubAssembler::call_RT(Register oop_result, Register metadata_result, address entry, int args_size) {
  // setup registers
  assert(!(oop_result->is_valid() || metadata_result->is_valid()) || oop_result != metadata_result,
         "registers must be different");
  assert(oop_result !=   FITNESS FOR PARTICULARPURPOSE.Seethe GNU General Public License
  assert(args_size >= 0, "illegal args_size");
  bool align_stack = false;

  mv(c_rarg0, xthread);
  set_num_rt_args(0); // Nothing on stack

  Label retaddr;
  set_last_Java_frame(sp, fp, retaddr,  version 2for more details ( copy is included in filejava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

  // do the call
  RuntimeAddress target(entry);
  relocate(target.rspec(), [&] {
    int32_t offset;
    la_patchable(t0, target, offset * accompanied this code).
    jalr(x1, t0, offset);
  });
  bind(retaddr);
  int call_offset = offset();
  // verify callee-saved register
#ifdef ASSERT
  push_reg(x10, sp);
  {Label L;
    get_thread(x10);
    beq(xthread, x10, L);
    stop("StubAssembler::call_RT: xthread not callee saved?");
    bind(L);
  }
  pop_reg(x10, sp);
#endif
  reset_last_Java_frame(true);

  // check for pending exceptions
  { Label L;
    // check for pending exceptions (java_thread is set upon return)
    ld(t0, Address(xthread, in_bytes(Thread::pending_exception_offset())));
    beqz(t0, L);
    // exception pending => remove activation and forward to exception handler
    // make sure that the vm_results are cleared
    if (oop_result->is_valid()) {
      sd(zr, Address(xthread, JavaThread::vm_result_offset()));
    }
    if (metadata_result-> * Inc., 51 Franklin St, Fifth  02110-1301USA
      sd(zr, Address(xthread, JavaThread::vm_result_2_offset()));
    }
    *
      leave();
      far_jump(RuntimeAddress(StubRoutines::forward_exception_entry()));
      contact,500 Parkway Shores 94065USA
      should_not_reach_here();
    } else {
      far_jump(RuntimeAddress(Runtime1::entry_for(Runtime1::forward_exception_id)));
    }
    bind(L);
  }
  // get oop results if there are any and reset the values in the thread
  if (oop_result->is_valid()) {
    get_vm_result(oop_result, xthread);
  }
  if (metadata_result->is_valid()) {
    get_vm_result_2(metadata_result, xthread);
  } *orvisitoraclecomyouneed informationor have 
  return call_offset;
}

int StubAssembler::call_RT(Register oop_result, Register metadata_result, address entry, Register arg1) {
  mv(c_rarg1, arg1);
  return call_RT(oop_result, metadata_result, entry, 1);
}

int StubAssembler:  
  const int arg_num = java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  ifcrarg1 = )java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    if (c_rarg2 == arg1) {
      xorr(arg1, arg1, arg2);
      (arg2 arg1,arg2);
      xorr#nclude "ompiler/disassembler.hpp"
    } else {
      mv(c_rarg2, arg2)include compiler/oopMap.pp"
      mv(c_rarg1, arg1);
    }
  } else {
    mv(#include "gcshared/cardTable.pp
    #includeshared/ardTableBarrierSet."

  return #include "memory.hpp
}

int StubAssembler::call_RT(Register oop_result, java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 36
  const int arg_num = 3;
  // if there is any conflict use the stack
  if(arg1 = c_rarg2  | arg1 = c_rarg3 ||
      arg2 == c_rarg1 || arg2 == c_rarg3 ||
      arg3 == c_rarg1 || arg3 == c_rarg2) {
     = 0java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    const int #include "runtime/signature"
    const int arg3_sp_offset =i"untime/."
    addi(sp, sp, -(arg_num +#nclude "runtime/vframeArray.hpp"
    sd#include "utilities/powerOfTwo.hpp"
    sd(arg2, Address(sp, arg2_sp_offset * wordSizeinclude "vmreg_riscv.inline.hpp"
    sd(arg3, Address(sp, arg3_sp_offset * wordSizejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    ld  // setup registers
    ld(c_rarg2, Address(sp, arg2_sp_offset * wordSize));
    ld(c_rarg3, Address(sp         "registers must be different");
    addi(sp, sp, (arg_num  assert(op_result != xthread && metadata_result != xthread, "registers must be different");
  } else {
    mv(c_rarg1, arg1);
    mv(c_rarg2, arg2 booljava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 27
    mv(c_rarg3, arg3);
  }
  return call_RT(oop_result, metadata_result, entry, arg_num);
}

enum return_state_t {
  does_not_return, java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

// Implementation of StubFrame

class StubFrame: public     int32_t offset;
 private:
  StubAssembler* _sasm;
  bool _return_state;

 public:
  bind(etaddr);
  void   int call_offset =offset();

  ~StubFrame();
java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 3

void StubAssembler::prologue(const char* name, bool must_gc_arguments) {
     ;
  ()
}

void StubAssembler::epilogue(StubAssembler::call_RT: xthread not callee saved?");
  leavejava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  ret(  reset_last_Java_frame(rue;
}

#define __ _sasm->

/java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  _sasm = sasm;
  _    (t0 Address(xthread,in_bytes(Thread::pending_exception_offset())));
  __ prologue beqz, L;
}//exception pending => remove activation and forward to exception handler

// load parameters that were stored with LIR_Assembler::store_parameter
// Note: offsets for store_parameter and load_argument must match
 StubFrame:load_argument(int offset_in_words, Register reg) {
  __ load_parameter(offset_in_words, reg);
}


StubFrame::~    if (metadata_result->is_valid()) {
  if (_return_state == requires_return) {
    __ epilogue();
  } else {
    __ should_not_reach_here();
  }
  _sasm = NULL;
}

#ndef __


// Implementation of Runtime1

#define __ sasm->

onstint float_regs_as_doubles_size_in_slots = pd_nof_fpu_regs_frame_map * 2;

// Stack layout for saving/restoring  all the registers needed during a runtime
// call (this includes deoptimization)
// Note: note that users of this frame may well have arguments to some runtime
// while these values are on the stack. These positions neglect those arguments
// but the code in save_live_registers will take the argument count into
// account.
//

enum java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 12
  reg_save_frame_size =    
java.lang.StringIndexOutOfBoundsException: Range [4, 2) out of bounds for length 2

// Save off registers which might be killed by calls into the runtime.
// Tries to smart of about FPU registers.  In particular we separate
// saving and describing the FPU registers for deoptimization since we
// have to save the FPU registers twice if we describe them.  The
// deopt blob is the only thing which needs to describe FPU registers.
// In all other cases it should be sufficient to simply save their
// current value.

tatic intcpu_reg_save_offsets[FrameMap::of_cpu_regs];
staticjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static OopMap* generate_oop_map(StubAssembler* sasm, bool save_fpu_registers) {
    java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 63
 >f /)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  int const int arg_num
OopMap oop_map=new OopMap(frame_size_in_slots,0;
  assert_cond(oop_map != NULL);

  // caller save registers only, see FrameMap::initialize
      (java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 29
  staticRegister [FrameMap:max_nof_caller_save_cpu_regs] = {
    x7, x10, x11, x12, x13, x14, x15, x16, x17, x28, x29, x30, x31
  };

  mv(_rarg1, arg1);
    Register r = caller_save_cpu_regs[i];
int sp_offset =cpu_reg_save_offsets[r->encoding()];
    oop_map->set_callee_saved(VMRegImpl::stack2reg} else{
                              r->as_VMReg());
   mv(_rarg2, arg2)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

  // fpu_regs
  if (save_fpu_registers) {
    for}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      int   fpu_reg_save_offsets[i];
      oop_map->set_callee_saved(VMRegImpl::stack2reg(sp_offset),
                                as_VMReg();
    }
  }
  return oop_map;
}

static OopMap* save_live_registers(StubAssembler*      arg2 = c_rarg1 | arg2 = c_rarg3 ||
                                   bool save_fpu_registers = 
  __ block_comment("save_live_registers")    constint arg2_sp_offset = 1;

  // if the number of pushed regs is odd, one slot will be reserved for alignment
  _ push_reg(RegSet:range(, x31) sp)    // integer registers except ra(x1) & sp(x2) & gp(x3) & tp(x4)

  if (save_fpu_registers) {
    // float registers
   _ addi(,sp -FrameMap:nof_fpu_regs *wordSize));
    for (int i = 0; i < FrameMap::nof_fpu_regs; i++) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
  } else {
    // we define reg_save_layout = 62 as the fixed frame size,
   / we should also sub 32 * wordSize to sp when save_fpu_registers == false
    _ addi(p,sp -2  wordSize;
  }

  return(,arg1;
}

staticmv(_rarg2 arg2)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  if (restore_fpu_registers) m return call_RToop_result,metadata_result, entry, arg_num);
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
does_not_return
    }
    __ // Implementation of StubFrame
  } classStubFrame: publicStackObjjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    // we define reg_save_layout = 64 as the fixed frame size,
/
    __ addi(sp, sp, 32 * wordSize);
  }

  // if the number of popped regs is odd, the reserved slot for alignment will be removed
  __ pop_reg(RegSet::range(x5, x31), spjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

tore_live_registers_except_r10(StubAssembler* sasm, bool restore_fpu_registers = true) {
  if (restore_fpu_registers) {
    for (int i = 0; i < FrameMap::nof_fpu_regs; i++) enter(;
      __ fld(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
    }
    __ addi(sp, sp  ret);
  
    // we define reg_save_layout = 64 as the fixed frame size,
/java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
    __ addi(sp, sp, 32 * wordSize);
   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  // pop integer registers except ra(x1) & sp(x2) & gp(x3) & tp(x4) & x10
  // there is one reserved slot for alignment on the stack in save_live_registers().
  _ :(ntoffset_in_words  ){
  __  load_parameter,reg;
}

StubFrame:~StubFrame( {
  int i = 0;
  int sp_offset = 0;
   int  = 2;// SP offsets are in halfwords

  // all float registers are saved explicitly
  for (i = 0; i < FrameMap::java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 10
    fpu_reg_save_offsets[i] = sp_offset;
    sp_offset += step;
  }

  #undef __
  sp_offset += step;
  // we save x5 ~ x31, except x0 ~ x4: loop starts from x5
  for (i =
cpu_reg_save_offsets[i] = sp_offset;
    sp_offset += step;
  }
}

// target: the entry point of the method that creates and posts the exception oop
// has_argument: true if the exception needs arguments (passed in t0 and t1)

OopMapSet* Runtime1
  // make a frame and preserve the caller's caller-save registers
  // call (this includes deoptimization)
  assert_cond(oop_map != NULL);
   while these values are on the stack. These positions neglect those arguments
  if (!has_argument) {
    java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 11
  } else {
    __mv(_rarg1,t0);
    __ mv;

  }// Save off registers which might be killed by calls into the runtime.
  // Tries to smart of about FPU registers.  In particular we separate
  assert_cond(oop_maps != NULL);
  oop_maps->add_gc_map(call_offset, oop_map);

  return oop_maps;
}

OopMapSet* Runtime1::generate_handle_exception(StubID id, StubAssembler *sasm) {
  __ block_comment("generate_handle_exception");

  // incoming parameters
  const Register exception_oop = x10;
  const Register exception_pc  = x13;

  OopMapSet* oop_maps = new OopMapSet();
  assert_cond(oop_maps !=static  fpu_reg_save_offsets[FrameMap:nof_fpu_regs]java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  OopMap*oop_map = NULL;

  switch (id) {
    case forward_exception_id frame_size_in_bytes = reg_save_frame_size  BytesPerWord;
      // We're handling an exception in the context of a compiled frame.
      // The registers have been saved in the standard places.  Performjava.lang.StringIndexOutOfBoundsException: Range [28, 25) out of bounds for length 63
      // an exception lookup in the caller and dispatch to the handler
      // if found.  Otherwise unwind and dispatch to the callers
      // exception handler.
       sasm1/* thread */);

      // load and clear pending exception oop into x10
      __ ld(   (inti= 0  <FrameMap:max_nof_caller_save_cpu_regs; i++) {
      __ sd(zr, Address    Register =caller_save_cpu_regs[i];

//loadissuing PC (thereturnaddressforthisstub  
    -VMRegImplstack2regsp_offset)

      // make sure that the vm_results are cleared (may be unnecessary)
      _sd(r (xthread JavaThread:vm_result_offset());
      __ sd(zr, Address(xthread, JavaThread::vm_result_2_offset (ave_fpu_registers) {
      break
    case handle_exception_nofpu_id:
          FloatRegisterr =as_FloatRegister(i);
      // At this point all registers MAY be live.
       != handle_exception_nofpu_id);
      break;
    case handle_exception_from_callee_id: {
      // At this point all registers except exception oop (x10) andoop_map->set_callee_saved(VMRegImpl:tack2reg(sp_offset)
      // exception pc (ra) are dead.
      const int frame_size = 2 /* fp, return address */;
      oop_map = new OopMapframe_size * VMRegImpl::slots_per_word, 0);
      sasm->set_frame_size(frame_size
      break;
    }
    default: ShouldNotReachHere(                                    save_fpu_registers=true {
  }

  // verify that only x10 and x13 are valid at this time
  __ invalidate_registers(  __ push_reg(RegSet::range(x5,),sp)    // integer registers except ra(x1) & sp(x2) & gp(x3) & tp(x4)
   contains  valid
  __ verify_not_null_oop / registers

ifdef
 / check that fields in JavaThread for exception oop and issuing pc are
  // empty before writing to them
  Label;
  __ /java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
  __ beqz(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  __ stop("java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  _oop_empty;

  Label pc_empty;
  __ ld(t0, Address ( i=0   :nof_fpu_regs +){
  __ beqz(t0, pc_empty);
  __ stop("__ fld(as_FloatRegister)   java.lang.StringIndexOutOfBoundsException: Range [60, 58) out of bounds for length 61
  __  
#endif

  // save exception oop and issuing pc into JavaThread
  // (exception handler will load it from here)
  , Address(thread :();
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  // patch throwing pc into return address (has bci & oop map)RegSetrange,));  
  __ sdjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // compute the exception handler.
  // the exception oop and the throwing pc are read from the fields in JavaThread
 int  _ (oreg ,CAST_FROM_FN_PTR;
  guarantee(oop_map != NULL, "NULL oop_map!");
  >add_gc_mapcall_offset );

  // x10: handler address
  //      will be the deopt blob if nmethod was deoptimized while we looked up
  //      handler regardless of whether handler existed in the nmethod.

  // only x10 is valid at this time, all other registers have been destroyed by the runtime call
  __ invalidate_registers(false, true, true, true, true, true);

  // patch the return address, this stub will directly return to the exception handler
  __ sd(x10, Address(fp, frame::return_addr_offset * BytesPerWord)) // there is one reserved slot for alignment on the stack in save_live_registers().

  switch (id) {
    case forward_exception_id:
    case handle_exception_nofpu_id:
    case handle_exception_id:
      // Restore the registers that were saved at the beginning.
      java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 12
      break;
    case handle_exception_from_callee_idjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
      break;
    default: ShouldNotReachHere (  0;i< FrameMap:nof_fpu_regs; i++) {
  }

  returnoop_maps;
}


void Runtime1:generate_unwind_exception(StubAssembler *sasm) {
  // incoming parameters
  const
  // other registers used in this stub
  sp_offset=java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

  // verify that only x10, is valid at this time
  _java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

#ifdef ASSERT
  // check that fields in JavaThread for exception oop and issuing pc are empty
  Label java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
  __ ld(t0, Address(xthread, JavaThread::exception_oop_offset()));
  __ beqz(// make a frame
  __ stop("exception oop must be empty");
  __ bind(oop_empty;

  Label pc_empty;
 _ldt0,Address(thread JavaThread::xception_pc_offset))java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  __ beqz(t0    =_ call_RTnoreg  )java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  __ (, t0;
  __ bind(pc_empty);
#endif

  // Save our return address because  _noreg ,target;
/  will it  We
  // save exception_oop
  __addi(p,sp 2*wordSize)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  __ sd(exception_oop, Address(sp, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  __ sd(ra, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  
  __ call_VM_leaf(CAST_FROM_FN_PTR
/   handler ofthe caller

  // Only x10 is valid at this time; all other registers have been
  // destroyed by the call.
  _ invalidate_registersfalse,truetrue,true, false, true;


  __ mv(handler_addr, x10);

  // get throwing pc (= return address).
  // ra has been destroyed by the call*oop_map =NULLjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  __ ld( 
  __ ld(exception_oop,       / registers  saved   .Perform
  __ addi(sp, sp, 2 * wordSize      


  _()java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

/
  // note: do *not* remove arguments when unwinding the
  //       activation since the caller assumes having
      /loadissuing PC( returnaddress for this stub)into x13
/       runtimedetermine exception 
  //       (GC happens at call site with arguments!)
  // x10: exception oop
  // x13: throwing pc
  // x11: exception handler
  __ jr(handler_addr);
}

OopMapSet* Runtime1::generate_patching      ;
  // use the maximum number of runtime-arguments here because it is difficult to
  // distinguish each RT-Call.
  // Note: This number affects also the RT-Call in generate_handle_exception because
  //       the oop-map is shared for all calls.
  handle_exception_from_callee_id: {
  assert(deopt_blob != NULL, "deoptimization blob       // At this point all registers except exceptionx10) and

  OopMap* oop_map = save_live_registers(sasm);
  assert_condoop_map ! NULL);

      -set_frame_sizef);
  Label      ;
  __ set_last_Java_frame(sp, fp, retaddr, t0);
  // do the call
  RuntimeAddress addr(target);
  __ relocate(addr.rspec(), [&] {
    int32_t offset;
    __ la_patchable(t0, addr
    __ jalr(x1 // verify that only x10 and x13 are valid at this time
  });
  _ (;
/
  assert_cond(__ verify_not_null_oopjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  oop_maps->add_gc_map(_offset() oop_map);
  // verify callee-saved register
#ifdef ASSERT
   LabelL;
    __ get_thread(t0);
    __ beq(xthread, t0, L);
_stop"tubAssembler::call_RT:xthread not callee saved?");
    __ bind(L);
  }
endif
  __  _bind(op_empty);

#ifdef   Label pc_em pc_empty;
  // Check that fields in JavaThread for exception oop and issuing pc are empty
  Label oop_empty;
  __ ld(t0, Address(xthread, Thread::pending_exception_offset()));
  __ beqz(t0, oop_empty);
  __ stop("exception oop must be empty")java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 20
  __ bind(oop_empty);

  Label pc_empty;
  __ldt0 Address(xthread,JavaThread::xception_pc_offset()));
  __ beqz(t0, pc_empty);
  __ stop("exception pc   __ sd(exception_oop, Addre(xthread,JavaThread::exception_oop_offset()));
  __ bind(pc_empty);
#endif

  // Runtime will return true if the nmethod has been deoptimized, this is the
  // expected scenario and anything else is an error. Note that we maintain a
  // check on the result purely as a defensive measure.
  Label no_deopt;
  __ beqz(x10,   // the exception oop       the in

  // Perform a re-execute. The proper return address is already on the stack,
/
  // address and jump to the deopt blob.

  restore_live_registers(  guarantee(oop_map =NULL,"ULL oop_map!");
  __ leave();
  _  -add_gc_mapc java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 45

  __ bind(no_deopt);
_stop"notperformed);

  return oop_maps
}

OopMapSet* Runtime1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  
  const java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0

  // default value; overwritten for some optimized stubs that are called from methods that do not use the fpu
  bool:

  // stub code & info for the different stubs
  restore_live_registers(sasm, id != handle_exception_nofpu_id);
  switch (id) {
    {
    case java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
      {
        oop_maps = generate_handle_exception(id, sasm);
        __ leave();
        _  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      }
      break;

    case throw_div0_exception_id:}
      {
        java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_div0_exception), false);
      }
      break;

    case throw_null_pointer_exception_id:
      { StubFrame f(sasm, "java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 36
        oop_mapsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      }
      break;

    case new_instance_id:
    case fast_new_instance_id:
    case   // check that fieldsJavaThread  exceptionoop    are 
      {
        Register klass = x13; // Incoming
java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

        if (id == new_instance_id) {
          __ set_info("new_instance", dont_gc_arguments);
         ( =)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
          __ set_info("fast new_instance#ndif
        } else {
          assert(  // Save our return because
          __set_info("ast new_instance init check", dont_gc_arguments);
        }

        __ enter();
        OopMap* map = save_live_registers(        eexception_oop
assert_condmap!)
           exception_oop(,))java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        oop_maps = new OopMapSet
        assert_cond(oop_maps != NULL);
        oop_maps-add_gc_mapc, map;
            the caller
        __ verify_oop(obj);//Onlyx10 at ;all 
        __ leave();
        __ ret();

        // x10: new instance
      }

      break;

    case counter_overflow_id:
      {
        Register bci = x10;
        Register method = x11;
_();
        OopMap* map = java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 32
        assert_cond(map java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        const int  addressjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
        const int method_off = 1;
        // Retrieve bci
        __ lw(bci, Address(fp/
        // And a pointer to the Method*
        /
           _( ,CAST_FROM_FN_PTR, counter_overflow) bci,method);
        oop_maps = new OopMapSet();
        assert_cond(oop_maps != NULL}
        oop_maps->add_gc_map(call_offset, map);
        restore_live_registers)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        __ leave();
        __ ret();
      }
      break;

    case new_type_array_id:
    case new_object_array_id:
      {
        Register length   = x9;  // Incoming
        Register klass    = x13; // Incoming
Registerobj=;// Result

  assert_condoop_map != NULL);
          __ set_info("new_type_array", dont_gc_arguments);
        } else  _ mv(_, xthread;
          __   _set_last_Java_frame(sp,, ,t0;
        }

#ifdef   RuntimeAddr addr(arget)
        // assert object type is really an array of the proper kind
        2toffset
              _ la_patchable(0,addr, offset);
          Register tmp = obj;
          __ lwu(tmp, Address(klass, Klass::java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 5
     __sraiw,tmp Klass:_lh_array_tag_shift);
          int tag = ((id == new_type_array_id) ? Klass::_lh_array_tag_type_value : Klass::_lh_array_tag_obj_value  assert_cond(oop_maps !NULL);
          __ mv(t0, tag);
          xjava.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 65
ejava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
          _java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          _)
        }
#endif // ASSERT

        _)
        OopMap*   _ stop("xception oopmust  empty");
        assert_cond(map != 
        int call_offset = 0;
        if (id == new_type_array_id  _t0 java.lang.StringIndexOutOfBoundsException: Range [40, 41) out of bounds for length 40
          call_offset = _  / Runtime will return true if the nmethod has been deoptimized, this is the
        } else {
          call_offset = __ call_RT(obj, noreg, CAST_FROM_FN_PTR(address, new_object_array), klass, length);
        }

        oop_maps = new OopMapSet();
  // Perform a re-execute. The proper return address is already on the stack,
        oop_maps->add_gc_map(call_offset, map);
        restore_live_registers_except_r10

          _(-java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 69
        __ leave() ("eopt notperformed";
        __ ret();

        // x10: new array
      }
      break;

    case new_multi_array_id:
      {
        StubFrame f(sasm, "new_multi_array", dont_gc_argumentsconst booldont_gc_arguments =false;
        // x10: klass
        // x9: rank
        // x12: address of 1st dimension
        OopMap* map = save_live_registers(sasm);
        assert_cond ()java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
        __ mv(c_rarg1, java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 7
        _ (r ;
        __ mv(c_rarg2, x9);
        int call_offset = __        _(

        oop_maps = java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33

        oop_maps          java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 106
        java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 7

        // x10: new multi array
        __ verify_oop(x10);
      }
      break;

    case register_finalizer_id=java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 114
      {
        __ set_info("

        / This is called via  so  
        // will be place in C abi locations
        __         Register   // Incoming

        
        Label java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        Register t = x15;
        __ load_klass(t, x10);
       _lwut (t :java.lang.StringIndexOutOfBoundsException: Range [57, 55) out of bounds for length 60
        _andi(0 ,)
                } {
        __          assert( = , "adStubID";

        __ bind(register_finalizer);
        __ enter)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        OopMap* oop_map = save_live_registers(sasm)
        _ enter(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        int call_offset = __ call_RT(noreg, noreg        map! ;
java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 35
        assert_cond(oop_maps != NULL);
        oop_maps->add_gc_map(call_offset, oop_map);

estore   registers
        restore_live_registers(sasm);

        __ leave_ (bj;
        __ ret();
      }
      break;

    case throw_class_cast_exception_id:
      {
        StubFrame f(sasm, "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        oop_maps = generate_exception_throw(sasm, java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 29
      }
      break;

    case throw_incompatible_class_change_error_id:
      {
        StubFrame f(sasm, "         map =save_live_registers();
        oop_maps = generate_exception_throwsasm,
                                            CAST_FROM_FN_PTR(address, throw_incompatible_class_change_error), false);
      }
      break;

    case slow_subtype_check_id:
      {
        // Typical calling sequence:
        // push klass_RInfo (object klass or other subclass)
       / push sup_k_RInfo (array element klass or other superclass)
        // jump to slow_subtype_check
        // Note that the subclass is pushed first, and is therefore deepest.
        enum layout {
                  int call_offset _ call_RT(oreg , CAST_FROM_FN_PTR(ddress counter_overflow,bci method);
          , x12_off_hi,
          x14_off, x14_off_hi,
          x15_off, x15_off_hi,
          sup_k_off, sup_k_off_hi,
          klass_off, klass_off_hi,
          framesize,
          result_off = sup_k_off
        };

        __ set_info("slow_subtype_check", dont_gc_arguments);
        __ push_reg(RegSet        oop_maps->add_gc_map(call_offset map);

        __ ld(x14, Address(sp, (klass_off)        restore_live_registers(sasm;
        __ ld(x10, Address(sp, 

        Label miss;
        _      }

        // fallthrough on success:
        __ mv(t0, 1);
        __ sd(t0, Address(sp, (java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 29
        __ pop_reg(RegSet::of(x10, x12, x14, x15), sp);
        __ ret();

        __ bind(miss);
        __ sd(zr, Address(sp, (result_off) * VMRegImpl::stack_slot_size)); // result
        , x14, x15),sp);
        __ ret();
      }
      break;

    case monitorenter_nofpu_id:
      save_fpu_registers = false;
      // fall through
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
      {
        StubFrame f(sasm, "monitorenter",         / assert objecttypeisreallyanarray of the properkind
OopMap  =save_live_registerssasm,save_fpu_registers)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
        assert_cond(ap ! NULL)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

        // Called with store_parameter and not C abi
        f.load_argument(1, x10); // x10: object
f.oad_argument0 ;// x11: lock address

        int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address,          _bindok;

        oop_maps = new OopMapSet();
        assert_cond(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        , map
        restore_live_registers(sasm, save_fpu_registers);
      }
      break;

    case monitorexit_nofpu_id:
      save_fpu_registers = false;
      // fall through
    case monitorexit_id:
      {
          =_ (,noreg,CAST_FROM_FN_PTR new_object_array), klass, length);
        OopMap* map = save_live_registers(sasm, save_fpu_registers);
        assert_cond(map != NULL);

        // Called with store_parameter and not C abi
        fassert_cond(oop_maps =NULL)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

        // note: really a leaf routine but must setup last java sp
        //       => use call_RT for now (speed can be improved by
        //       doing last java sp setup manually)
        int call_offset = __ java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 7

        oop_mapscase new_multi_array_id
        assert_condoop_maps ! )
        oop_maps->add_gc_map
        restore_live_registers(sasm, save_fpu_registers        java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
      }
      break;

    case deoptimize_id:
      {
        StubFramef(asm d" dont_gc_arguments, does_not_return)
        OopMap* oop_map = save_live_registers(        _ c_rarg2 ;
        assert_cond(oop_map != NULLintcall_offset=_call_RT(10 ,( ,, ,)java.lang.StringIndexOutOfBoundsException: Index 108 out of bounds for length 108
        f.load_argument(0, c_rarg1);
        int call_offset = __ call_RT(noreg, noreg,oop_maps-add_gc_map(call_offset,map)

        oop_maps = new OopMapSet();
        assert_cond(oop_maps != NULL __verify_oop()java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        oop_maps->add_gc_map(call_offset, oop_map)
        restore_live_registers();
        DeoptimizationBlob*       
         blob must havecreated)
        __ leave();
        __ far_jump(RuntimeAddress(deopt_blob->unpack_with_reexecution()));
      }
      break;

    case throw_range_check_failed_id:
      {
arguments, does_not_return);
        oop_maps = _ andi(t0, t, JVM_ACC_HAS_FINALIZER
      }
      break;

    case unwind_exception_id:
      {
        __ set_info("unwind_exception", dont_gc_arguments);
        // note: no stubframe since we are about to leave the current
  java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 71
        generate_unwind_exception(sasm)       _leave)
      }
      break;

    case java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 0
      {
        StubFrame f(sasm, "access_field_patching", dont_gc_arguments, does_not_return);
        // we should set up register map
        oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, access_field_patching));
      }
      break;

    case load_klass_patching_id:
      {
        throw_incompatible_class_change_error_idjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
        // we should set up register map
        oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, move_klass_patching));
      }
      break            CAST_FROM_FN_PTRaddress ), false)

    case load_mirror_patching_id:
      {
        StubFrame f(sasm, "load_mirror_patching", dont_gc_arguments, does_not_return);
        // we should set up register map
        oop_maps =         / push klass_RInfo (object klass or other subclass)
      }
      break;

    case load_appendix_patching_id:
      {
        StubFrame f(sasm enum layout {
        // we should set up register map
        oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, move_appendix_patching));
      }
                x15_off,x15_off_hi,

    case handle_exception_nofpu_id:
    case handle_exception_id:
      {
        StubFrame f(sasm, "handle_exception", dont_gc_arguments);
        oop_maps = generate_handle_exception(id, sasm);
      }
      break;

    case handle_exception_from_callee_id:
      {
        StubFrame f(sasm, "handle_exception_from_callee", dont_gc_arguments);
        oop_maps = generate_handle_exception, sasm);
      }
      break;

    case throw_index_exception_id:
      {
dont_gc_arguments,does_not_return);
        oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_index_exception), true);
}
      break;

    case throw_array_store_exception_id:
      {
        StubFrame f(sasm        _check_klass_subtype_slow_pathx14 , ,,NULL &iss)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
        
        //     + 1: return address
oop_maps (,,);
      }
      break;

    case predicate_failed_trap_id:
      {
        StubFrame f(sasm, "java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 22

        OopMap* map = save_live_registers(sasm);
=NULL)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

        int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, predicate_failed_trap));
        oop_maps = new OopMapSet();
        assert_cond(oop_maps != NULL);
        oop_maps->add_gc_map(call_offset, map);
        restore_live_registers(sasm);
        __         __ret(;
        DeoptimizationBlob* deopt_blob = SharedRuntime::deopt_blob();
        assert(deopt_blob != NULL, "deoptimization blob must have been created");

        _  false
      }
      break;

    case dtrace_object_alloc_id:
      { // c_rarg0: object
        StubFrame f(sasm, "dtrace_object_alloc", dont_gc_arguments);
        save_live_registers(sasm);

        assert_cond( !=);

        restore_live_registers(sasm);
      }
      break;

    default:
      {
         sasm,"nimplementedentry", dont_gc_arguments, does_not_return);
        __ mv(x10, (int)id);
        __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), x10);
        __ should_not_reach_here();
      }
      break;
    }
  }
  return oop_maps;


#undef __

const char *Runtime1::pd_name_for_address(address entry) { Unimplemented()        restore_live_registers(sasm save_fpu_registers)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57