* Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
E NOTICESOR 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
   by the Free Foundation.
 *
 Thiscodeis distributedin  hope itwill ,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 code).
 *
 * 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,
  Inc. 51Franklin St,FifthFloor,,1301USA
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle*
 *  /
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 /

#include "precompiled.hpp"
#include "classfile/stackMapTableFormat.hpp"
#include "interpreter/bytecodes.hpp"
#include "memory/metadataFactory.hpp"
#include "memory/oopFactory.hpp"
#include "oops/method.inline.hpp"
#include "oops/oop.inline.hpp"
#include "runtime/handles.inline.hpp"
#include "runtime/relocator.hpp"

#define MAX_METHOD_LENGTH  65535

#define MAX_SHORT ((1 << 15) - 1)
#define MIN_SHORT (- (1 << 15))

// Encapsulates a code change request. There are 3 types.
// General instruction, jump instruction, and table/lookup switches
//
lass bool) {returnfalse }
  int _bci;
 public
   // accessors
   virtual bool handle_code_changeintbci()    {return _; }

   // type info
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   // accessors ChangeWiden :public  {
   int bci)     return _;java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
   void relocate(int public

   virtual bool adjust(int bci, int delta) { return false; }

   // debug
   virtual void print() = 0;
};

class ChangeWiden : new_ilen new_ilen;
  int              _new_ilen;    // New length of instruction at bci
  u_char*          _inst_buffer; _nst_buffer =inst_buffer
 publicjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ChangeWiden( , new_ilen,u_char* inst_buffer)  (ci) java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
      ;
    _inst_buffer =};
  }

  // Callback to do instruction
boolhandle_code_change(Relocator *r) { return r->handle_widen(bci(), _new_ilen, _inst_buffer); };

  void   ChangeJumpWiden( bci,int):ChangeItem(){ _ =delta; }
};

class java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  int _delta;  / New length of instruction at bci
 public:
  JumpWidenint bci  ):ChangeItembci){delta=delta;}

  // Callback to do instruction
  bool handle_code_change(Relocator *r) { return r->handle_jump_widen(bci(), _delta); };

  // If the bci matches, adjust the delta in the change jump request. bci) = ){
  bool adjust(int jump_bci, int delta)delta+ ;
    ifdelta- ;
      if (_delta > 0)
        _delta += delta;
      else
        _delta -= delta;
      return true;
    }
    return false;
  }

voidprint(){tty>(" : dDelta%,bci) d;}
};

class ChangeSwitchPad : public ChangeItem {
  int    
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 public:
   ChangeSwitchPad(int bci, int padding, bool is_lookup_switch) : ChangeItem(bci) {
     _ ChangeSwitchPad : public ChangeItem {
     _is_lookup_switch = is_lookup_switch;
   }

   // Callback to do instruction
   boolhandle_code_change( *r){ returnr>handle_switch_pad(bci(), _padding, _is_lookup_switch); };

   bool is_switch_pad()        { return true; }
   intChangeSwitchPad(int ,intpadding,bool is_lookup_switch) : ChangeItem(bci) {
   bool      _adding  ;

   void print()


//-----------------------------------------------------------------------------------------------------------
// Relocator code

Relocator::Relocator(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  set_method(m);
  set_code_length(method()->code_size());
  set_code_array(NULL);(     {_s_lookup_switch }
  voidprint)                 tty->" :dPadding d  : d"b() _padding i;}
  if (!expand_code_array(0)) {
    // Should have at least MAX_METHOD_LENGTH available or the verifier
    // would have failed.
    ShouldNotReachHere();// Relocator code
  }Relocator:Relocator(onst &m,*){
  set_method(m)
  set_code_length(-code_size()java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  _listener = listenerif!expand_code_array() {{
}

// size is the new size of the instruction at bci. Hence, if size is less than the current
// instruction size, we will shrink the code.
methodHandle :insert_space_atintbciint size u_charinst_buffer[] TRAPS) {
  _changes = new GrowableArray<ChangeItem*> (10);
  _changes->push(new ChangeWiden(bci, size, inst_buffer));

  if(TraceRelocator) {
    ttyset_compressed_line_number_tableNULL;
    _method->print();
    _method->print_codes();
    tty->print_cr("---    (
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  if (!handle_code_changes()) return (int bci,int ,  inst_buffer[],TRAPS {

    // Construct the new method
   new_method = Method::clone_with_new_data(method(),
                              code_array(), code_length(),
                              compressed_line_number_table(),
          compressed_line_number_table_size()
                              CHECK_(methodHandle()));

  // Deallocate the old Method* from metadata
    method->(;
  loader_data->add_to_deallocate_list(method()());

        _method_ethod>print_codes();

  if (TraceRelocator) {
    tty->print_cr("-------------------------------------------------");
    tty->print_cr("new method");
    _method->print_codes();
  }

  return new_method;
}


  if(handle_code_changes()returnmethodHandlejava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  (_changes! ,"changes must  initialized")

  while (!_changes->is_empty( code_array(, code_length(),
    // Inv: everything is aligned.
    ChangeItem* ci = _changes->first();

    if (TraceRelocator) {
      ci-print(;
    }

    // Execute operation
    if (!(ethodHandle);

    // Shuffle items up
    for (int index
      _changes->at_put(index-1  *   (-method_holder()->)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    _tty-print_cr(--------------------------)
  }
   true
}


bool Relocator::java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    case Bytecodes::_tableswitch:       return false;
    case   assert(_changes (_hanges ! , changesvector must beinitialized";
     Bytecodes:_:// rewritten _lookupswitch
    java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    : ShouldNotReachHere)
  }
  return true
}

// We need a special instruction size method, since lookupswitches and tableswitches might not be
// properly aligned during relocation
int Relocator::rc_instr_len(int bci) {
  Bytecodesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   (c {
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    // padding recorded.
    :tableswitch:
    case Bytecodes::_lookupswitch:
    java.lang.StringIndexOutOfBoundsException: Range [18, 8) out of bounds for length 39
    case Bytecodes::_fast_binaryswitch:
    {
       pad= get_orig_switch_pad(, b);
      if (pad == -1) {
        return instruction_length_at(bci)   (bc{
      }
      // Otherwise, depends on the switch type.Bytecodes:_lookupswitch:                  
       (){
 :java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 79
          int return;// dummy
          int hi = int_at(bci + 1 + pad + 4 * 2);
          n  -  1;
          return 1 Bytecodes:Codebc code_at()
        }
        caseBytecodes:l:
        case Bytecodes     Bytecodes:tableswitch
        case Bytecodes::_fast_binaryswitch: {
=int_atbci+1 pad  4  1;
          return 1 + pad + 4*(2 + 2*npairs);
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        default:
          ShouldNotReachHere();
      }
    }
    switch (){
     ;
  }
   instruction_length_at(bci);
}

// If a change item is recorded for "pc", with type "ct", returns the
// associated padding, else -1.
int::(int bci,bool is_lookup_switch){
   (int k= 0 k <_>(; +){
               1  pad 4( +n)
    if (ci->is_switch_pad()) {
        }
      if (csp        case ::_lookupswitch:
        return csp->paddingcase Bytecodes:_fast_binaryswitch {
      }
    }
  }
  return -1;
}


// Push a ChangeJumpWiden if it doesn't already exist on the work queue,
// otherwise adjust the item already there by delta.  The calculation for
// new_delta is wrong for this because it uses the offset stored in the
// code stream itself which wasn't fixed when item was pushed on the work queue.
::push_jump_widen( bci,  delta, new_delta)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  for 
    ChangeItem* ci = _changes->at(j);
    if (ci->adjust(bci, delta)) return;
  }
  _changes->push(new ChangeJumpWiden(bci, new_delta));
}


// The current instruction of "c" is a jump; one of its offset starts
// at "offset" and is a short if "isShort" is "TRUE",
// and an integer otherwise.  If the jump crosses "breakPC", change
// the span of the jump by "delta".
voidRelocator:change_jump( bci,int offset   break_bciint delta) java.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91
  int bci_delta = (is_short) ? short_at(offset) : int_at(offset);
  int targ = bci + java.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 37

  if ((bci <= break_bci && targ >  break_bci) ||
      (    &  <=)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    int new_delta;
    if (bci_delta > 0)
      new_delta = bci_delta + delta
    else
      new_delta = bci_delta - delta;

    if (is_short && ((new_delta > MAX_SHORT) || // new_delta is wrong for this because it uses the offset stored in the
      push_jump_widen(bci, delta, new_delta);
    }else ifis_short)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
      short_at_put(offset, for (int j = 0; j < _changeslength(; +){
    } else {
      int_at_put(    ChangeItem* ci =*  =_changes>()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    }
  }
}


// Changes all jumps crossing "break_bci" by "delta".  May enqueue things
// on "rc->changes"
void Relocator::change_jumps(int break_bci, // and an integer otherwise.  If the jump crosses "breakPC", change
  int bci Relocatorchange_jump(nt , int offset,bool is_short    delta){
   bci_delta=()? ():int_at(;
  // Now, adjust any affected instructions.
  ( code_length java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        
      case  -delta
Bytecodesi
      case (bci ,new_delta;
      case :ijava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
      case Bytecodes::_int_at_put( ;
      case Bytecodes::_ifle
      case java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
      case Bytecodes::_void Relocator::change_jumps(int  delta){
      case Bytecodes::_if_icmplt:
      case Bytecodes::_if_icmpge:
      case Bytecodes bci =0
       :_:
      case /
      case while (bci < code_lengthbci  ) {
      case      case :_:
      case Bytecodes:_ifnonnull:
      java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 28
case::ifgt
              case Bytecode:_ifle:
        break;
      case Bytecodes::_goto_w:
      case Bytecodes::_jsr_w:
        change_jump(bci, bci+1, false, break_bci, delta aseBytecodes::if_icmpltjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        break;
       :if_icmple:
      case Bytecodes case :_if_acmpeq:
       Bytecodes:fast_linearswitch
      case Bytecodes::_case Bytecodes::_ifnull:
        int recPad = get_orig_switch_pad(bci, (bc != Bytecodes::_tableswitch));
        int oldPad = (ecPad! -1 ?recPad : align(bci1 - (+1;
        if (bci > break_bci) {
          int new_bci = bci + delta;
          int newPad =align(ew_bci+)-(ew_bci+1;
          // Do we need to check the padding?
          if (newPad != oldPad      Bytecodes:jsr:
            if (recPad == -1) {change_jump(,bci+,true , )java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
              _changescase Bytecodes:j:
            }
          }
        }

        // Then the rest, which depend on the kind of switch.Bytecodes:_java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        caseBytecodes:fast_binaryswitch:java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
          : {
            change_jump(bci, bci +1 + oldPad, false        int oldPad= (recPad !=-1  recPad :align+1 -(bci+1);
            // We cannot use the Bytecode_tableswitch abstraction, since the padding might not be correct.
             lo  int_at(bci + 1+ 
            int  = int_at(bci +1+ oldPad +4 * 2;
            int n = hi - lo + 1;
           for(int k = 0;k<n k+){
              change_jump(bci, bci +1 + oldPad + java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 31
            }
            // Special next-bci calculation here...
            bci += 1
            continue;
          }
          case Bytecodes::_lookupswitch:
          java.lang.StringIndexOutOfBoundsException: Range [45, 46) out of bounds for length 45
          case Bytecodescase Bytecodes:tableswitch: {
            change_jump(bci, bci+1 + oldPad, false, break_bci,delta);
            // We cannot use the Bytecode_lookupswitch abstraction, since the padding might not be correct.(bci, bci +1+ oldPad,false break_bci,delta)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
            int npairs = int_at(bci + 1 + int lo = int_at(bci + 1 + oldPad + 4;
             intk= ;k <  ++){
              change_jump(bci, bci + 1 + oldPad + 4*(2 +  ntn = hi-lo  1;
            }
            
            bci += 1}
            continue;
          }
          bci= 1 + oldPad + (n+3)*4;
            ShouldNotReachHere();
        }
      }
      default:
        break;
    }
    bci += rc_instr_len(bci);
  }
}

// The width of instruction at "pc" is changing by "delta".  Adjust the
// exception table, if any, of "rc->mb".
void:int bci  delta java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  ExceptionTable table(_method());
  forintindex = 0   .length(;index + {
    if (table.start_pc(index) > bci) {
      table. Bytecodes:fast_binaryswitch:{
      table.set_end_pc(change_jump(bci bci 1+oldPad, ,break_bci ;
    } else if (bci < table.end_pc(index)) {
      table.set_end_pc(index, table.end_pc(index) + delta);
    }
    if (table.handler_pc(index) > bci)
      table.for (int k 0;   npairs k){
  }
}


// The width of instruction at "bci" is changing by "delta".  Adjust the line number table.
void Relocator            /* Special next-bci calculation here... */
   (>has_linenumber_table) {
    CompressedLineNumberReadStream              java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
}
          }
      int adjustment = (reader.bci() > bci) ? delta : 0;
      writer.rite_pair(eader.bci()+ ,readerline);
    }
    writer.write_terminator();
        break;
    et_compressed_line_number_table_size(writer.position());
  }
}


// The width of instruction at "bci" is changing by "delta".  Adjust the local variable table.
void Relocator::adjust_local_var_table}
  int localvariable_table_length = method()->localvariable_table_length();
  if (localvariable_table_length c" is changing by "delta".  Adjust the
     Relocator::adjust_exception_tableint bci,  ){
    for( i  0   localvariable_table_length;i+) {
      u2 current_bci = table[i].start_bci;
       ( >bci){
        table[i].start_bci = current_bcitable.(,table.()  );
      }else{
           <.indexjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        if (current_bci + current_length       set_handler_pc( .andler_pc()
          table[i].length =
        }
      }
    }
  }
}

// Create a new array, copying the src array but adding a hole at
// the specified location
ssLoaderData*loader_data
    size_tCompressedLineNumberWriteStreamwriter(64;  
  JavaThread*THREAD =:c(; 
  Array<u1>* dst =
1>( ->length( +hole_sz, ,CHECK_NULL)java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90

   src_addr=(address)src->adr_at(0);
  address dst_addr = (address)dst->adr_at(0);

  memcpy(dst_addr, src_addr, where);
  java.lang.StringIndexOutOfBoundsException: Range [35, 8) out of bounds for length 36
         src_addr + where, java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 3
  return dst;
}

// The width of instruction at "bci" is changing by "delta".  Adjust the stack
// map frames.
void Relocator::adjust_stack_map_table(int bci, int delta) {
  if (method()->has_stackmap_table()) {
    Array<u1>* data = method()->stackmap_data();
    // The data in the array is a classfile representation of the stackmap table
    stack_map_table* sm_table =
        stack_map_table::at((address)data->adr_at(0));

    int count = sm_table->number_of_entries();
    stack_map_frame* frame = sm_table->entries();
    int bci_iter = -1;
    bool offset_adjusted = false; // only need to adjust one offset

    for (int i = 0; i < count; ++i) {
      int offset_delta = frame->offset_delta();
      bci_iter += offset_delta;

      if (!offset_adjusted && bci_iter > bci) {
        int new_offset_delta = offset_delta + delta;

        if (frame->is_valid_offset(new_offset_delta)) {
          frame->set_offset_delta(new_offset_delta);
        } else {
          assert(frame->  int localvariable_table_length= method()>localvariable_table_length();
                 frame->is_same_locals_1_stack_item_frame(),
                 Framemust beone  theforms)
          // The new delta exceeds the capacity of the 'same_frame' orinti= ;i < localvariable_table_length;++ java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
          // 'same_frame_1_stack_item_frame' frame types.  We need to
          // convert these frames to the extended versions, but the extended
          // version is bigger and requires more room.  So we allocate a
          // new array and copy the data, being sure to leave u2-sized hole[]length = + 
          
          //
          // the specified location
n an extended    .

          size_t     size_t where, inthole_sz,Array<> ) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

          ClassLoaderData*loader_data  (-method_holder(;
          Array<u1>*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          if (new_data =addressdst_addr address)-a(;
            java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 36
           ,src-( -where
          /Deallocateolddata
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
          data = new_data;

                addressframe_addr=()data-adr_at()+frame_offset)
          frameif method)->(


          // Now convert the frames in place
          if (frame->is_same_frame()) {
            same_frame_extended::create_at(frame_addr, new_offset_delta);
          } else {
            same_locals_1_stack_item_extended::create_at(
              frame_addr, new_offset_delta, NULL);
            // the verification_info_type should already be at the right spot
          }
        }
        offset_adjusted = true; // needs to be done only once, since subsequent
                                // values are offsets from the current
      }

  // The stack map frame may contain verification types, if so we need to
      // check and update any Uninitialized type's bci (no matter where it is).
      int for(nti= 0  <count;+i){
      verification_type_info* types = frame-types(;

      for (int i = 0; i < java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 31
        if (types->is_uninitialized() && types->bci() intnew_offset_delta  offset_delta  delta;
          types->java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 0
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        types = types->next();
      }

      // Full frame has stack values too
      full_frame* ff = frame->as_full_frame();
      if ( frame>is_same_locals_1_stack_item_frame(),
        address eol = (address)types;
        number_of_types = ff"Frame must beone of thecompressed forms");
        types = ff->stack(eol);
         // The new delta exceeds the capacity of the 'same_frame' or
          if (types->is_uninitialized() && types->bci() > bci) {
            types->set_bci(types->bci() + delta);
          }
          types = types->java.lang.StringIndexOutOfBoundsException: Range [10, 1) out of bounds for length 75
        }
      }

      frame = frame- can   usedin extendedversion oftheframe.
    }size_t frame_offset = (address)frame - (address)data->adr_at(0);

    )>et_stackmap_data(ata) // in case it has changed
  }
}


bool Relocator::expand_code_array(int delta) {
  int length = MAX2(code_length() + delta, java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 11

  if (java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 26
    if (deltaaddress   (address)data->adr_at()+ frame_offset)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
       = MAX_METHOD_LENGTH;
    } else {
      return false;
    }
  }

new_code_array=NEW_RESOURCE_ARRAY( char,length);
  if          }else {

              frame_addr, new_offset_delta, NULL);
  if (code_array() !=             // the verific should already be the right spot
    memcpy(new_code_array,         offset_adjusted = true;offset_adjusted = true; // needs to be done only once, since subsequent
  } else {
    // Initial copy. Copy directly from Method*
    memcpy(new_code_array, method/
  }

  set_code_array(new_code_array);
  set_code_array_length(length);

  return true;
}


// The instruction at "bci", whose size is "ilen", is changing size by
// "delta".  Reallocate, move code, recalculate jumps, and enqueue
// change items as necessary.
bool Relocator:types>set_bci(types-bci( + delta)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  int next_bci = java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 7
  if (delta > 0 && code_length() + delta > java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    // Expand allocated code space, if necessary.
    if (!address eol=(address)types;
          return ;
    }
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  // We require 4-byte alignment of code arrays.
  eck code alignment";
  // Change jumps before doing the copying; this routine requires aligned switches.
  change_jumps(bci, delta);

  // In case we have shrunken a tableswitch/lookupswitch statement, we store the last
  // bytes that get overwritten. We have to copy the bytes after the change_jumps method
  // has been called, since it is likely to update last offset in a tableswitch/lookupswitch
  assert(delta >= -tmethod(->set_stackmap_data(ata;// in case it has changed
  if}
    memcpy(_overwritejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
  }

  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
  set_code_length(code_lengthif(elta =0& code_length()< MAX_METHOD_LENGTH{
  // Also adjust exception tables...=MAX_METHOD_LENGTH;
  adjust_exception_table      return falsejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  // Line number tables...
  ( )
  // And local variable table...
  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 37

  // Adjust stack maps
  adjust_stack_map_table(ci ;

  // Relocate the pending change stack...
for(nt j=0   changes->) j+ {
    ChangeItem  set_code_arraynew_code_array)
    ci-rb,delta
  }

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  notify(bci// "delta".  Reallocate, move code, recalculate// change items as necessary.

   = +;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

// relocate a general instruction. Called by ChangeWiden class
bool Relocator
   ilen bci)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  if (!relocate_code(bci, ilen, new_ilen - ilen))
    change_jumps(bci,delta)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

  // Insert new bytecode(s)
  for(int k = 0; k < new_ilen; k++) {
    code_at_put(bci + k, (Bytecodes::Code/ has been , sinceitis  tolastoffsetin lookupswitch
}

  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 33
}

// handle jump_widen instruction. Called be ChangeJumpWiden class
boolexception ..
  int ilen = rc_instr_len(bci//Line number .

  Bytecodes: bc= code_atb;
  switch (bc) {
    case Bytecodes::_/ Adjust stack maps
    case Bytecodes::_ifne:
    case Bytecodes::_iflt:
    case Bytecodes::_ifge:
    :_java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    case Bytecodes::_ifle:
    case Bytecodes::_if_icmpeq:
    case Bytecodes::_if_icmpne(,delta java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 36
    case Bytecodes Relocator::handle_widen(nt bci, int new_ilen, u_char inst_buffer[]) {
    case if (!relocate_co ilen,new_ilenilen)
    case Bytecodes::_if_icmpgt:
    case Bytecodes::_if_icmple:for(k=0k   ++ java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    case Bytecodes::
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    case:( , delta) java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    case Bytecodes::_ifnonnull: {
      const int  Bytecodes:Codebc  bci;

      // If 'if' points to the next bytecode after goto, it's already handled.
      // it shouldn't be.
      assert (short_at(bci+1) != ilen+java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 26
      assert(ilen == 3, "check length")case:ifle:

      // Convert to 0 if <cond> goto 6
      //            3 _goto 11
      //            6 _goto_w <wide delta offset>
      //            11 <else code>
      const int goto_w_length = java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 31
      constcase Bytecodes:_:

   !(bci 3,/

      // if bytecode points to goto_w instruction
      short_at_put(bci + 1, = Bytecodes:length_for(ytecodes:goto;

      int cbci = bci + ilen;
      // goto around
      code_at_put(cbci, Bytecodes::_goto
      short_at_putcbci  ,add_bci)
      // goto_w <wide delta>
      cbci = cbci + goto_length;
      code_at_putcbci _)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
      if
        delta + ;                 /goto_wis2 bytesmore than if"code
      } else {
        delta -= ilen+goto_length;  // branch starts at goto_w offsetcode_at_putcbci Bytecodes:g;
      }
      int_at_put(cbci + 1,       // goto_w <wide delta>
      break;

      }
    case Bytecodes::_goto:
    case Bytecodes::_jsr:
      assert(ilen == 3, "check length");

      if (!relocate_code(bci, 3, 2)) return false;
      if (bc == Bytecodes::_goto)
        code_at_put(bci, Bytecodes::_goto_w);
      else
        code_at_put(bci, Bytecodes::_jsr_w);

      // If it's a forward jump, add 2 for the widening.
      if (delta > 0) delta += 2;
      int_at_put( delta+=2;                
      ;

    defaultint_at_put( +1,delta;
  }

  java.lang.StringIndexOutOfBoundsException: Range [6, 8) out of bounds for length 7
}

// handle lookup/table switch instructions.  Called be ChangeSwitchPad class
bool Relocator:      (ilen= 3, "check length";
  
  new_pad = align(bci+1) - (bci+1);
  int=:_)
  bci :_)
    int len      else
    if (!is_lookup_switch) {
      int low  = int_at(bci+1+old_pad+4);
      int high = int_at(bci+1+old_pad+8);
       = -+ + ;// 3 for default, hi, lo.
    } else {
      int npairs = int_at(bci+1+java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
      len = npairs*2 + 2; // 2 for default, npairs.
    }
    // Because "relocateCode" does a "changeJumps" loop,
    // which parses instructions to determine their length,
    /we  tocall    with thecurrent
    // instruction.  Since it may also overwrite the current
   // instruction when moving down, remember the possibly
    /overwrittenpart.

    // Move the code following the instruction...
    if (!relocate_code(bci, ilen, d;

  if(pad_delta ){
      // Move the shrunken instruction down.
      memmove(addr_at(bci + 1 + new_pad),
              addr_at(bci + 1 + old_pad),
              len * 4 + pad_delta);
      memmove(addr_at(bci + 1 + new_pad + len*4 + pad_delta),
              overwrite pad_delta;
    } else {
      assert(pad_delta > 0, "check");
      // Move the expanded instruction up.
      memmove(bci +1 + 
              addr_at(bci +1 +npairs = int_at(+1old_pad+4);
              len * 4);
     memset(addr_atbci + ) 0,new_pad);// pad must be 0
    }
  }
  return ;
}