Quelle  relocator.cpp   Sprache: C

/*
 * Copyright (c) 1997, 2018, Oracle and/or its affiliates. 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 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., 51 Franklin St, Fifth  * 
 *
 * Please contact  * DO NOT ALTER OR REMOVCOPYRIGHT  OR THISFILE .
 *published by the Free Software .  *  isdistributed inthe that be useful,  WITHOUT
 *,51 Franklin   Floor,Boston MA 02110-1301 USA.
 *
 */

#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
//
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  int _bci;
 public:
   // ChangeItem : public ResourceObj {
   virtual bool handle_code_change(Relocator *r) = 0;

   // type info
   virtual bool is_switch_pad() { return false; 

   // accessors
    (     _bci
   void 

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

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

class publicChangeItem
int bci(    {return_bci;}
  u_char*          _inst_buffer; // New bytecodes
 :
  ChangeWidenjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    _ = java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
    i  ;
  }

  // Callback to do instruction
  bool  intbci,int ,  ):ChangeItem(ci {

  void _new_ilen=new_ilen
}

class   // Callback to
     java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 100

  ChangeJumpWiden(int bci,intbci  delta  ChangeItembci){_elta  }

  // Callback to do instruction
  boolint/

  // If the bci matches, adjust the delta in the change jump request.Change( bci,intdelta)  ( { _elta   java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    //
    if(()=jump_bci 
      if (_delta > 0)
        _ =delta;
      else
        _ =deltajava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      returnelse
    }
       ()                 -print_crChangeJumpWiden.bci:%   : d" (,_elta) java.lang.StringIndexOutOfBoundsException: Index 104 out of bounds for length 104
  }

  void print()                 { tty->print_cr("java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 8
};

classjava.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for length 43
   Relocator  -java.lang.StringIndexOutOfBoundsException: Range [79, 70) out of bounds for length 110
  bool _is_lookup_switch;
 public:
   intbci,    java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 83
     p=padding
     _java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   }

   //-----------------------------------------------------------------------------------------------------------
   bool java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 17

   bool is_switch_pad()        { return true; }
   int  padding()              { return _java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 16
h)      return i;}

    (                { -print_cr(ChangeSwitchPad.bci: %   :%  IsLookupSwitch %, ci),padding,_s_lookup_switch) java.lang.StringIndexOutOfBoundsException: Index 147 out of bounds for length 147
};

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

Relocator:RelocatorcmethodHandle& ,RelocatorListener*listener 
  ;
  (method)>);
  set_code_array(NULL);
  // Allocate code array and copy bytecodes
   (expand_code_array0) 
    // Should have at least MAX_METHOD_LENGTH available or the verifier
    // would have failed.
    // instruction size, we will shrink themethodHandleRelocator:(nt , int ,u_char [,TRAPSjava.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
   ){
  ()java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
t_compressed_line_number_table_size0);
  _listener = listener;
}

// 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.
atint size u_char ){
  _
  _methodHandlejava.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 65

  if (TraceRelocator)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    _print()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    _-java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
    >java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 32
  }

 (handle_code_changes))return ();

    // Construct the new method
  methodHandle new_method = Method::clone_with_new_dataassert_changes !NULL, "changes vector mustbe )
                              ) java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
                              compressed_line_number_table(),
                              compressed_line_number_table_size      ci->)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
                              CHECK_methodHandle())java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

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

    set_method(new_method)}

  if (TraceRelocator) {
   tty>"---------------------------";
    tty  return;
    _method->print_codes
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  return new_method;
}


bool java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  assertchanges !NULL   must be )

  caseBytecodes::fast_linearswitch              
    // Inv: everything is aligned.
    ChangeItem* ci = _changes-    default: (;

    if (TraceRelocator}
      ci-// We need a special instruction size method, since lookupswitches and tableswitches might// properly aligned during relocation
    }

    // Execute operation
      switch(){

    // Shuffle items up
    for (int     case Bytecodes:_:
      _changes->case Bytecodes::_fast_linearswitch:
    }
    _changes->pop();
  }
  return true;
}


bool      int  =bci, is_opcode_lookupswitch(c)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  switch() {
    case Bytecodes:      }
    case :_:                  // not rewritten on ia64
switch (bc {
    caseBytecodes:_fast_binaryswitch: return true; // rewritten _lookupswitch
    default: ShouldNotReachHere();
  }
   true; // dummy
}

// We need a special instruction size method, since lookupswitches and tableswitches might not be
// properly aligned during relocation
int Relocator::          int  =hi- o+ 1
  ::Code =code_atbci);
  switch (bc) {
         Bytecodes:_ookupswitch:
    // padding recorded.
    caseBytecodes:_:
    case Bytecodes::_lookupswitch:
    case Bytecodes::_fast_linearswitch:
    case Bytecodes::_=(   +pad + *)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    {
      int pad         }
      if (pad == -1) {
        return instruction_length_at(bci);
      }
      // Otherwise, depends on the switch type.
       bc 
        case  breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
          int lo = int_at(bci  return java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 36
 Relocatorget_orig_switch_pad(int bci   {
for(  =0;k< changes-length) k+ {
          return1 +  + *3  );
  }
case Bytecodes:lookupswitch
        case Bytecodes::_fast_linearswitch:
        caseBytecodes:fast_binaryswitch:{
          int java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 7
          return 1          ChangeJumpWiden if it doesn't already exist on the work queue,
        }
        default:
          void Relocator:push_jump_widenint  int  intnew_delta {
      }
    }
    default:
      break;
  }
  return instruction_length_at(bci)}
}
// The current instruction of "c" is a jump; one of its offset starts
// If a change item is recorded for "pc", with type "ct", returns the
// associated padding, else -1.
int Relocatorvoid Relocator:int  ,bool is_short, is_short, intbreak_bci, intdelta) {
java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 65
    ChangeItem* ci = _changes->at(k);
    if (ci->is_switch_pad()) {
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
      if (csp->is_lookup_switch() =bci>break_bci& targ=break_bci) {
        return csp->padding();
      }
    }
  }
  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.
void Relocator::push_jump_widen(int bci  ( {
  ->) j+ java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    ChangeItem ci= _changes-at(j);
    if (ci->adjust(bci, delta)) return;
  }
  _
}


// 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".
void::(ntbci int offset is_short,intbreak_bci,int delta {
  int  is_short  short_atoffset  offset)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  int targ = bci + bci_delta;

  if ((bci <= break_bci && targ >  break_bci) ||
      (  while (ci < code_length()) {
    int new_delta;
    if (bci_delta > 0)
      new_delta = bci_delta + delta;
    else
      new_delta=bci_delta - delta;

          case ::_fne:
      push_jump_widen, delta, );
    } else  caseBytecodes:_fge:
      short_at_put(offset, new_delta);
    } else {
      offset,new_delta)
    }
  }
}


// Changes all jumps crossing "break_bci" by "delta".  May enqueue things
// on "rc->changes"
 break_bci,intdelta java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  int  ;
  Bytecodes:caseBytecodes:_if_icmple:
  / Now, adjust any affected instructions.
  while (bci<code_length() 
    switch (bc= code_at(bci)) {
       Bytecodes:ifeq
      case Bytecodes :ifnonnull
      case Bytecodes::_iflt:
      case Bytecodes::_ifge:
       Bytecodes:ifgt:
      s::_java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
      case Bytecodes::_if_icmpeq:
      case Bytecodes::_if_icmpne:
       :::
      case Bytecodes::_if_icmpge:
      case Bytecodes::_if_icmpgt:
      caseBytecodes:_if_icmple
           Bytecodes:_:
      case Bytecodes::case :_:
      java.lang.StringIndexOutOfBoundsException: Range [29, 10) out of bounds for length 30
      caseoldPad r =-1) : alignbci+)- bci)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
      case Bytecodes::_          int newPad = align   n+ -n+1)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
      case :_jsrjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        bci bci1,,break_bci,delta);
        break;
      case Bytecodes::_goto_w:
      caseBytecodes:_sr_w:
        java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 13
        break;
      case :tableswitch:
      case Bytecodes::_lookupswitch:
      case Bytecodes::_fast_linearswitch:
      case Bytecodes::_:{
        int recPad = case Bytecodes::_tableswitch
int  != 1)?recPad (bci1)-bci);
        if (bci > break_bci) {
          int new_bciint lo =int_at(  oldPad + 4 * 1);
          int int hihi  bci +  oldPad   2)
          // Do we need to check the padding?
          if (newPad !for ( k  0;   ;+)
            if (recPad == -1) {
              }
            }
          }
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 9

        case Bytecodes::_fast_linearswitch:
        switch (bc) {
          :_ 1   falsebreak_bci, ;
            change_jump( 1   , ;
            // We cannot use the Bytecode_tableswitch abstraction, since the padding might not be correct.
             * 1);
            int hi = int_at(bci + 1 +for(nt   0 < npairs;k+ {
            nt  = hi - +1
            for (int k = 0; k < n; k++) {
            /* Special next-bci calculation here... */
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            // Special next-bci calculation here...
             + Relocator:adjust_exception_table( bci,int){
            continue;
          }
          case Bytecodes::_lookupswitch:
          case Bytecodes::_fast_linearswitchfor (nt = 0;index<table.) index+)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
          case:_fast_binaryswitch 
            , bci+  oldPad,false, ,delta)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
            // We cannot use the Bytecode_lookupswitch abstraction, since the padding might not be correct.
            int npairs    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            = 0 k<npairs; ++ java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
              change_jump(bci
            }
            /* Special next-bci calculation here... */
            bci += 1 + oldPad +if(method()-has_linenumber_table() {
            continue;
          }
          default:
            ShouldNotReachHere();
        }
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      default.(.(  adjustment .();
    
sjava.lang.StringIndexOutOfBoundsException: Range [57, 41) out of bounds for length 61
    bci += rc_instr_len(bci);
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

// The width of instruction at "pc" is changing by "delta".  Adjust the
// exception table, if any, of "rc->mb".
void(intbci int delta {
for inti=0;i<localvariable_table_length i+){
  java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 42
    if(urrent_bci  {
      set_start_pc(index start_pcindex +delta)
            } els} else {
    } elseif(bci < table.end_pc()) {
      table.set_end_pc(index, table.end_pc(index) + delta);
    }
    if (table.handler_pc(index) > bci)
      table.index,table.index) + delta)
  }
}


// The width of instruction at "bci" is changing by "delta".  Adjust the line number table.
void   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  if (method()->has_linenumber_table()) {
    CompressedLineNumberReadStream  ssLoaderData*,
    CompressedLineNumberWriteStream writer(64) // plenty big for most line number tables
    while (reader.read_pair()) {
      int adjustment = (reader.bci() > bci)   THREAD =JavaThread:urrent) // For exception macros.
      writer.write_pair(reader.      MetadataFactory::new_array<uloader_data,src>)   0 CHECK_NULL;
    }
    address =addresssrc>java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 45
    memcpy(dst_addr + where + hole_sz,
    set_compressed_line_number_table_size(writer.position());
  }
}


// The width of instruction at "bci" is changing by "delta".  Adjust the local variable table.
void Relocator::java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 14
 =)-localvariable_table_length;
  if (localvariable_table_length > 0) {
    LocalVariableTableElement" be ofthe compressed ";
    for ( i  0;i< localvariable_table_length i+{
      u2 current_bci = table[i].start_bci;
      if (current_bci > bci) {
        table[i].start_bci = current_bci + delta;
      } else {
        u2 current_length = table[i].length// convert these frames to the extended versions, but the extended
        if (current_bci + current_length > bci) {
          tablei.length  current_length + delta;
        }
      }
    }
  }
}

// Create a new array, copying the src array but adding a hole at
// the specified location
static Array<u1>* insert_hole_atextended version oftheframe
  u1>*src){
  JavaThread* THREAD = JavaThread::current(); // For exception macros.
  Array<u1>* dst =
      MetadataFactory::new_array<u1>(loader_data           =method()>()->class_loader_data()

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

  memcpy(dst_addr, src_addr, where);
  memcpy(dst_addr + where + hole_sz,
         src_addr +where, -length()- );
  return dst/   
}

// The width of instruction at "bci" is changing by "delta".  Adjust the stack
// map frames.
          address frame_addr =address(-adr_at0  )
  (()->as_stackmap_table()) {
    Array<u1>* data java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    // The data in the array is a classfile representation of the stackmap table
    java.lang.StringIndexOutOfBoundsException: Range [8, 19) out of bounds for length 9
        stack_map_table::at((address)data->adr_at(0));

    int
    
        // The stack map frame may contain verification types, if so we need to
    bool offset_adjusted = false; // only need to adjust one offset

     i   0;i<count +)
      types=>ypes()java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
      bci_iter += offset_delta;

      if (!offset_adjusted && bci_iter > bci) {
         =+java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

        if (frame->is_valid_offset(new_offset_delta)) }
          frame->
        }java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          assert(java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 46
                 -java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 60
                 Frame of  java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 62
         
          // '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
          // right after the 'frame_type' for the new offset field.
          //
          java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
          /can stillbe in an     .

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

          ClassLoaderData* loader_datamethod(-sd;// in case it has changed
          Array
          if (new_data == java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            return; // out-of-memory?
          }
          // Deallocate old data
          MetadataFactory::free_array<u1
          data = new_data;

          frame_addr =((>0  ;
          frame = stack_map_frame::atlengthjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33


          // Now convert the frames in place
          if
            har*  = unsigned ;
          }else{
            same_locals_1_stack_item_extended::create_at
              java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 50
ation_info_type should be at right 
          }
        }
        java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 79
                                // 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).
        set_codjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 32
  returntrue

      for (int i = 0; i < number_of_types; 
        if (types// The instruction at "bci", whose size is "ilen// "delta".  Reallocate, move code, recalculate jumps, and enqueue
          -types>)  ;
        }
        types = types->next();
      }

      // Full frame has stack values too
      full_frame* ff = frame->as_full_frame();
      if (ff != // Expand allocated
          types
        number_of_typesfalsejava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        types = ff->stack}
}
          if (types->is_uninitialized() && types->bci
            types->set_bci(types->bci() +   assert(((intptr_t)code_array() & 3) == 0, "chalignment)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
          }
          types = types->next();
        }
      }

      frame = frame->next();
    }

    )>d) 
  }
}


bool Relocator::expand_code_array(int delta) {
  int java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 3

  if (length > MAX_METHOD_LENGTH) {
     d=  &code_length) =MAX_METHOD_LENGTH) java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
      length = MAX_METHOD_LENGTH;
    } else {
       ;
    }
  }

  unsigned  // Line number tables...
  if (!adjust_line_no_tablebci,delta;

  // Expanding current array
  if (  adjust_local_var_table(bci, delta);
    memcpy(new_code_array, code_array(), code_length());
  } else {
    // Initial copy. Copy directly from Method*
    memcpy(new_code_array, method()->code_base(), code_length adjust_stack_map_tableb,delta)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
   intj  ;j <_>length(;+){

  set_code_array();
  ci->relocate->elocate(ci, delta);

  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::relocate_code(int bci, int ilen, int delta) {
  int next_bci = bci +ilen;
  if (delta > 0 }
    // Expand allocated code space, if necessary.
    if (!expand_code_array
          return false;
    }
  }

  // We require 4-byte alignment of code arrays.
  int =rc_instr_len(bci;
  // Change jumps before doing the copying; this routine requires aligned switches.
   ;

  // 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 beencalled it is likely to update last offset in atableswitch/
  assert(delta >= -3,   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
  if (delta < 0 && delta >= -3) {
    memcpy(_overwrite, addr_at(bci + ilen + delta), -delta);
  }

  memmove(addr_at(next_bci + delta), addr_at(next_bci), code_length() - next_bci);
  set_code_length(code_length() + delta);
 Also adjust exceptiontables..
  adjust_exception_table(bci, delta);
  / Line numbertables..
  adjust_line_no_table(bci, delta);
  // And local variable table...
  adjust_local_var_table:Code =code_at(ci)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 /java.lang.StringIndexOutOfBoundsException: Range [17, 11) out of bounds for length 22
  adjust_stack_map_tablejava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 26

  // Relocate the pending change stack...Bytecodes:ifge
  forcase Bytecodes::ifgt:
    ChangeItem* ci = _changes->at(j);
    ci->relocate(bci, delta);
  }

  // Notify any listeners about code relocation
  notifybci delta,code_length());

  return true;
}

// relocate a general instruction. Called by ChangeWiden class
boolRelocator::(ntjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  int ilen = rc_instr_len(bci);
  de(bci, , new_ilen - ilen)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    return false;

  // Insert new bytecode(s)
  (int  =0; <new_ilen; k+){
    code_at_put(bci + k, (Bytecodes::Code)inst_buffer[k]);
  }

  return true;
}

// handle jump_widen instruction. Called be ChangeJumpWiden class
bool Relocator:handle_jump_widenint bci intdelta) {
  int ilen = rc_instr_len(bci);

Bytecodes:: =code_at()java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  switch (bc) {
    case Bytecodes::_ifeq:
    case Bytecodes::_ifne:
    case Bytecodes::_iflt:
    case Bytecodes::_ifge:
    case Bytecodes::_ifgt:
    case Bytecodes:_java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    case Bytecodes::_if_icmpeq:
    case Bytecodes::_if_icmpne:
    case Bytecodes::_if_icmplt:
    case Bytecodes::_if_icmpge:
    case Bytecodes::_if_icmpgt:
    case Bytecodes::_if_icmple:
     :if_acmpeq:
    case
    if(relocate_codebci,3, /*delta*/add_bci)) return false;
    case Bytecodes::_ifnonnull: {
  =Bytecodes:B:_oto)

      // If 'if' points to the next bytecode after goto, it's already handled.
      // it shouldn't be.
      assert      // goto around
      assert(ilen == 3, "check length");

      // Convert to 0 if <cond> goto 6short_at_put(+1 )
      //            3 _goto 11
      //            6 _goto_w <wide delta offset>
      //            11 <else code>
      const int goto_w_length = Bytecodes::length_for(Bytecodes::_goto_w);
      const int add_bci = goto_length + goto_w_length;

      if (!relocate_code(bci, 3, /*delta*/add_bci)) return false;

      // if bytecode points to goto_w instructioncode_at_put(,Bytecodes::goto_w;
      short_at_put(bci + 1, ilen + goto_length);

      int cbci =         +2//goto_w  2   than" 
      // goto around
      (, :_oto)
      short_at_put(cbci + 1, add_bci);
      java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
      cbci = java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0
      code_at_put
      if (delta > 0) {
         ;// goto_w is 2 bytes more than "if" code
      } else {
        delta -break
      }
      int_at_putcbci  1 );
      break;

      }
    case Bytecodes::_goto:
    case java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
      assert =check length"java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

      if (!relocate_code(bci, 3,  int =
      if (bc == Bytecodes:goto
        code_at_put(, 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(bci + 1, len = high-ow1  3;
      break;

    default: ShouldNotReachHere();
  }

  return true;
}

// handle lookup/table switch instructions.  Called be ChangeSwitchPad class
bool Relocator   need that beforemessingwith the 
  int ilen =// instruction when moving down, remember the possibly
      /  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
d;
  if (pad_delta !  if pad_delta <0 
    int len;
    if (!is_lookup_switch) {
      int java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 35
      int high = int_at(bci+1+old_pad+8);              _overwrite, -pad_delta)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      len =
    } elsememmove(addr_at+ +new_pad),
      int=bci+1+java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 43
      len = npairs*2 +(  1, ,new_pad); 
    }
    // Because "relocateCode" does a "changeJumps" loop,
    // which parses instructions to determine their length,true
    // we need to call that before messing with the current
    // instruction.  Since it may also overwrite the current
    // instruction when moving down, remember the possibly
    // overwritten part.

    // Move the code following the instruction...
    if (!relocate_code(bci, ilen, pad_delta)) return false;

    if (pad_delta < 0) {
      // 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(addr_at(bci +1 + new_pad),
              addr_at(bci +1 + old_pad),
              len * 4);
      memset(addr_at(bci + 1), 0, new_pad); // pad must be 0
    }
  }
  return true;
}