relocator.cpp revision 1472:c18cbe5936b8
1/* 2 * Copyright (c) 1997, 2005, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25# include "incls/_precompiled.incl" 26# include "incls/_relocator.cpp.incl" 27 28#define MAX_METHOD_LENGTH 65535 29 30#define MAX_SHORT ((1 << 15) - 1) 31#define MIN_SHORT (- (1 << 15)) 32 33// Encapsulates a code change request. There are 3 types. 34// General instruction, jump instruction, and table/lookup switches 35// 36class ChangeItem : public ResourceObj { 37 int _bci; 38 public: 39 ChangeItem(int bci) { _bci = bci; } 40 virtual bool handle_code_change(Relocator *r) = 0; 41 42 // type info 43 virtual bool is_widen() { return false; } 44 virtual bool is_jump_widen() { return false; } 45 virtual bool is_switch_pad() { return false; } 46 47 // accessors 48 int bci() { return _bci; } 49 void relocate(int break_bci, int delta) { if (_bci > break_bci) { _bci += delta; } } 50 51 virtual bool adjust(int bci, int delta) { return false; } 52 53 // debug 54 virtual void print() = 0; 55}; 56 57class ChangeWiden : public ChangeItem { 58 int _new_ilen; // New length of instruction at bci 59 u_char* _inst_buffer; // New bytecodes 60 public: 61 ChangeWiden(int bci, int new_ilen, u_char* inst_buffer) : ChangeItem(bci) { 62 _new_ilen = new_ilen; 63 _inst_buffer = inst_buffer; 64 } 65 66 // Callback to do instruction 67 bool handle_code_change(Relocator *r) { return r->handle_widen(bci(), _new_ilen, _inst_buffer); }; 68 69 bool is_widen() { return true; } 70 71 void print() { tty->print_cr("ChangeWiden. bci: %d New_ilen: %d", bci(), _new_ilen); } 72}; 73 74class ChangeJumpWiden : public ChangeItem { 75 int _delta; // New length of instruction at bci 76 public: 77 ChangeJumpWiden(int bci, int delta) : ChangeItem(bci) { _delta = delta; } 78 79 // Callback to do instruction 80 bool handle_code_change(Relocator *r) { return r->handle_jump_widen(bci(), _delta); }; 81 82 bool is_jump_widen() { return true; } 83 84 // If the bci matches, adjust the delta in the change jump request. 85 bool adjust(int jump_bci, int delta) { 86 if (bci() == jump_bci) { 87 if (_delta > 0) 88 _delta += delta; 89 else 90 _delta -= delta; 91 return true; 92 } 93 return false; 94 } 95 96 void print() { tty->print_cr("ChangeJumpWiden. bci: %d Delta: %d", bci(), _delta); } 97}; 98 99class ChangeSwitchPad : public ChangeItem { 100 int _padding; 101 bool _is_lookup_switch; 102 public: 103 ChangeSwitchPad(int bci, int padding, bool is_lookup_switch) : ChangeItem(bci) { 104 _padding = padding; 105 _is_lookup_switch = is_lookup_switch; 106 } 107 108 // Callback to do instruction 109 bool handle_code_change(Relocator *r) { return r->handle_switch_pad(bci(), _padding, _is_lookup_switch); }; 110 111 bool is_switch_pad() { return true; } 112 int padding() { return _padding; } 113 bool is_lookup_switch() { return _is_lookup_switch; } 114 115 void print() { tty->print_cr("ChangeSwitchPad. bci: %d Padding: %d IsLookupSwitch: %d", bci(), _padding, _is_lookup_switch); } 116}; 117 118//----------------------------------------------------------------------------------------------------------- 119// Relocator code 120 121Relocator::Relocator(methodHandle m, RelocatorListener* listener) { 122 set_method(m); 123 set_code_length(method()->code_size()); 124 set_code_array(NULL); 125 // Allocate code array and copy bytecodes 126 if (!expand_code_array(0)) { 127 // Should have at least MAX_METHOD_LENGTH available or the verifier 128 // would have failed. 129 ShouldNotReachHere(); 130 } 131 set_compressed_line_number_table(NULL); 132 set_compressed_line_number_table_size(0); 133 _listener = listener; 134} 135 136// size is the new size of the instruction at bci. Hence, if size is less than the current 137// instruction sice, we will shrink the code. 138methodHandle Relocator::insert_space_at(int bci, int size, u_char inst_buffer[], TRAPS) { 139 _changes = new GrowableArray<ChangeItem*> (10); 140 _changes->push(new ChangeWiden(bci, size, inst_buffer)); 141 142 if (TraceRelocator) { 143 tty->print_cr("Space at: %d Size: %d", bci, size); 144 _method->print(); 145 _method->print_codes(); 146 tty->print_cr("-------------------------------------------------"); 147 } 148 149 if (!handle_code_changes()) return methodHandle(); 150 151 // Construct the new method 152 methodHandle new_method = methodOopDesc::clone_with_new_data(method(), 153 code_array(), code_length(), 154 compressed_line_number_table(), 155 compressed_line_number_table_size(), 156 CHECK_(methodHandle())); 157 set_method(new_method); 158 159 if (TraceRelocator) { 160 tty->print_cr("-------------------------------------------------"); 161 tty->print_cr("new method"); 162 _method->print_codes(); 163 } 164 165 return new_method; 166} 167 168 169bool Relocator::handle_code_changes() { 170 assert(_changes != NULL, "changes vector must be initialized"); 171 172 while (!_changes->is_empty()) { 173 // Inv: everything is aligned. 174 ChangeItem* ci = _changes->first(); 175 176 if (TraceRelocator) { 177 ci->print(); 178 } 179 180 // Execute operation 181 if (!ci->handle_code_change(this)) return false; 182 183 // Shuffel items up 184 for (int index = 1; index < _changes->length(); index++) { 185 _changes->at_put(index-1, _changes->at(index)); 186 } 187 _changes->pop(); 188 } 189 return true; 190} 191 192 193bool Relocator::is_opcode_lookupswitch(Bytecodes::Code bc) { 194 switch (bc) { 195 case Bytecodes::_tableswitch: return false; 196 case Bytecodes::_lookupswitch: // not rewritten on ia64 197 case Bytecodes::_fast_linearswitch: // rewritten _lookupswitch 198 case Bytecodes::_fast_binaryswitch: return true; // rewritten _lookupswitch 199 default: ShouldNotReachHere(); 200 } 201 return true; // dummy 202} 203 204// We need a special instruction size method, since lookupswitches and tableswitches might not be 205// properly alligned during relocation 206int Relocator::rc_instr_len(int bci) { 207 Bytecodes::Code bc= code_at(bci); 208 switch (bc) { 209 // In the case of switch instructions, see if we have the original 210 // padding recorded. 211 case Bytecodes::_tableswitch: 212 case Bytecodes::_lookupswitch: 213 case Bytecodes::_fast_linearswitch: 214 case Bytecodes::_fast_binaryswitch: 215 { 216 int pad = get_orig_switch_pad(bci, is_opcode_lookupswitch(bc)); 217 if (pad == -1) { 218 return instruction_length_at(bci); 219 } 220 // Otherwise, depends on the switch type. 221 switch (bc) { 222 case Bytecodes::_tableswitch: { 223 int lo = int_at(bci + 1 + pad + 4 * 1); 224 int hi = int_at(bci + 1 + pad + 4 * 2); 225 int n = hi - lo + 1; 226 return 1 + pad + 4*(3 + n); 227 } 228 case Bytecodes::_lookupswitch: 229 case Bytecodes::_fast_linearswitch: 230 case Bytecodes::_fast_binaryswitch: { 231 int npairs = int_at(bci + 1 + pad + 4 * 1); 232 return 1 + pad + 4*(2 + 2*npairs); 233 } 234 default: 235 ShouldNotReachHere(); 236 } 237 } 238 } 239 return instruction_length_at(bci); 240} 241 242// If a change item is recorded for "pc", with type "ct", returns the 243// associated padding, else -1. 244int Relocator::get_orig_switch_pad(int bci, bool is_lookup_switch) { 245 for (int k = 0; k < _changes->length(); k++) { 246 ChangeItem* ci = _changes->at(k); 247 if (ci->is_switch_pad()) { 248 ChangeSwitchPad* csp = (ChangeSwitchPad*)ci; 249 if (csp->is_lookup_switch() == is_lookup_switch && csp->bci() == bci) { 250 return csp->padding(); 251 } 252 } 253 } 254 return -1; 255} 256 257 258// Push a ChangeJumpWiden if it doesn't already exist on the work queue, 259// otherwise adjust the item already there by delta. The calculation for 260// new_delta is wrong for this because it uses the offset stored in the 261// code stream itself which wasn't fixed when item was pushed on the work queue. 262void Relocator::push_jump_widen(int bci, int delta, int new_delta) { 263 for (int j = 0; j < _changes->length(); j++) { 264 ChangeItem* ci = _changes->at(j); 265 if (ci->adjust(bci, delta)) return; 266 } 267 _changes->push(new ChangeJumpWiden(bci, new_delta)); 268} 269 270 271// The current instruction of "c" is a jump; one of its offset starts 272// at "offset" and is a short if "isShort" is "TRUE", 273// and an integer otherwise. If the jump crosses "breakPC", change 274// the span of the jump by "delta". 275void Relocator::change_jump(int bci, int offset, bool is_short, int break_bci, int delta) { 276 int bci_delta = (is_short) ? short_at(offset) : int_at(offset); 277 int targ = bci + bci_delta; 278 279 if ((bci <= break_bci && targ > break_bci) || 280 (bci > break_bci && targ <= break_bci)) { 281 int new_delta; 282 if (bci_delta > 0) 283 new_delta = bci_delta + delta; 284 else 285 new_delta = bci_delta - delta; 286 287 if (is_short && ((new_delta > MAX_SHORT) || new_delta < MIN_SHORT)) { 288 push_jump_widen(bci, delta, new_delta); 289 } else if (is_short) { 290 short_at_put(offset, new_delta); 291 } else { 292 int_at_put(offset, new_delta); 293 } 294 } 295} 296 297 298// Changes all jumps crossing "break_bci" by "delta". May enqueue things 299// on "rc->changes" 300void Relocator::change_jumps(int break_bci, int delta) { 301 int bci = 0; 302 Bytecodes::Code bc; 303 // Now, adjust any affected instructions. 304 while (bci < code_length()) { 305 switch (bc= code_at(bci)) { 306 case Bytecodes::_ifeq: 307 case Bytecodes::_ifne: 308 case Bytecodes::_iflt: 309 case Bytecodes::_ifge: 310 case Bytecodes::_ifgt: 311 case Bytecodes::_ifle: 312 case Bytecodes::_if_icmpeq: 313 case Bytecodes::_if_icmpne: 314 case Bytecodes::_if_icmplt: 315 case Bytecodes::_if_icmpge: 316 case Bytecodes::_if_icmpgt: 317 case Bytecodes::_if_icmple: 318 case Bytecodes::_if_acmpeq: 319 case Bytecodes::_if_acmpne: 320 case Bytecodes::_ifnull: 321 case Bytecodes::_ifnonnull: 322 case Bytecodes::_goto: 323 case Bytecodes::_jsr: 324 change_jump(bci, bci+1, true, break_bci, delta); 325 break; 326 case Bytecodes::_goto_w: 327 case Bytecodes::_jsr_w: 328 change_jump(bci, bci+1, false, break_bci, delta); 329 break; 330 case Bytecodes::_tableswitch: 331 case Bytecodes::_lookupswitch: 332 case Bytecodes::_fast_linearswitch: 333 case Bytecodes::_fast_binaryswitch: { 334 int recPad = get_orig_switch_pad(bci, (bc != Bytecodes::_tableswitch)); 335 int oldPad = (recPad != -1) ? recPad : align(bci+1) - (bci+1); 336 if (bci > break_bci) { 337 int new_bci = bci + delta; 338 int newPad = align(new_bci+1) - (new_bci+1); 339 // Do we need to check the padding? 340 if (newPad != oldPad) { 341 if (recPad == -1) { 342 _changes->push(new ChangeSwitchPad(bci, oldPad, (bc != Bytecodes::_tableswitch))); 343 } 344 } 345 } 346 347 // Then the rest, which depend on the kind of switch. 348 switch (bc) { 349 case Bytecodes::_tableswitch: { 350 change_jump(bci, bci +1 + oldPad, false, break_bci, delta); 351 // We cannot use the Bytecode_tableswitch abstraction, since the padding might not be correct. 352 int lo = int_at(bci + 1 + oldPad + 4 * 1); 353 int hi = int_at(bci + 1 + oldPad + 4 * 2); 354 int n = hi - lo + 1; 355 for (int k = 0; k < n; k++) { 356 change_jump(bci, bci +1 + oldPad + 4*(k+3), false, break_bci, delta); 357 } 358 // Special next-bci calculation here... 359 bci += 1 + oldPad + (n+3)*4; 360 continue; 361 } 362 case Bytecodes::_lookupswitch: 363 case Bytecodes::_fast_linearswitch: 364 case Bytecodes::_fast_binaryswitch: { 365 change_jump(bci, bci +1 + oldPad, false, break_bci, delta); 366 // We cannot use the Bytecode_lookupswitch abstraction, since the padding might not be correct. 367 int npairs = int_at(bci + 1 + oldPad + 4 * 1); 368 for (int k = 0; k < npairs; k++) { 369 change_jump(bci, bci + 1 + oldPad + 4*(2 + 2*k + 1), false, break_bci, delta); 370 } 371 /* Special next-bci calculation here... */ 372 bci += 1 + oldPad + (2 + (npairs*2))*4; 373 continue; 374 } 375 default: 376 ShouldNotReachHere(); 377 } 378 } 379 default: 380 break; 381 } 382 bci += rc_instr_len(bci); 383 } 384} 385 386// The width of instruction at "pc" is changing by "delta". Adjust the 387// exception table, if any, of "rc->mb". 388void Relocator::adjust_exception_table(int bci, int delta) { 389 typeArrayOop table = method()->exception_table(); 390 for (int index = 0; index < table->length(); index +=4) { 391 if (table->int_at(index) > bci) { 392 table->int_at_put(index+0, table->int_at(index+0) + delta); 393 table->int_at_put(index+1, table->int_at(index+1) + delta); 394 } else if (bci < table->int_at(index+1)) { 395 table->int_at_put(index+1, table->int_at(index+1) + delta); 396 } 397 if (table->int_at(index+2) > bci) 398 table->int_at_put(index+2, table->int_at(index+2) + delta); 399 } 400} 401 402 403// The width of instruction at "bci" is changing by "delta". Adjust the line number table. 404void Relocator::adjust_line_no_table(int bci, int delta) { 405 if (method()->has_linenumber_table()) { 406 CompressedLineNumberReadStream reader(method()->compressed_linenumber_table()); 407 CompressedLineNumberWriteStream writer(64); // plenty big for most line number tables 408 while (reader.read_pair()) { 409 int adjustment = (reader.bci() > bci) ? delta : 0; 410 writer.write_pair(reader.bci() + adjustment, reader.line()); 411 } 412 writer.write_terminator(); 413 set_compressed_line_number_table(writer.buffer()); 414 set_compressed_line_number_table_size(writer.position()); 415 } 416} 417 418 419// The width of instruction at "bci" is changing by "delta". Adjust the local variable table. 420void Relocator::adjust_local_var_table(int bci, int delta) { 421 int localvariable_table_length = method()->localvariable_table_length(); 422 if (localvariable_table_length > 0) { 423 LocalVariableTableElement* table = method()->localvariable_table_start(); 424 for (int i = 0; i < localvariable_table_length; i++) { 425 u2 current_bci = table[i].start_bci; 426 if (current_bci > bci) { 427 table[i].start_bci = current_bci + delta; 428 } else { 429 u2 current_length = table[i].length; 430 if (current_bci + current_length > bci) { 431 table[i].length = current_length + delta; 432 } 433 } 434 } 435 } 436} 437 438 439bool Relocator::expand_code_array(int delta) { 440 int length = MAX2(code_length() + delta, code_length() * (100+code_slop_pct()) / 100); 441 442 if (length > MAX_METHOD_LENGTH) { 443 if (delta == 0 && code_length() <= MAX_METHOD_LENGTH) { 444 length = MAX_METHOD_LENGTH; 445 } else { 446 return false; 447 } 448 } 449 450 unsigned char* new_code_array = NEW_RESOURCE_ARRAY(unsigned char, length); 451 if (!new_code_array) return false; 452 453 // Expanding current array 454 if (code_array() != NULL) { 455 memcpy(new_code_array, code_array(), code_length()); 456 } else { 457 // Initial copy. Copy directly from methodOop 458 memcpy(new_code_array, method()->code_base(), code_length()); 459 } 460 461 set_code_array(new_code_array); 462 set_code_array_length(length); 463 464 return true; 465} 466 467 468// The instruction at "bci", whose size is "ilen", is changing size by 469// "delta". Reallocate, move code, recalculate jumps, and enqueue 470// change items as necessary. 471bool Relocator::relocate_code(int bci, int ilen, int delta) { 472 int next_bci = bci + ilen; 473 if (delta > 0 && code_length() + delta > code_array_length()) { 474 // Expand allocated code space, if necessary. 475 if (!expand_code_array(delta)) { 476 return false; 477 } 478 } 479 480 // We require 4-byte alignment of code arrays. 481 assert(((intptr_t)code_array() & 3) == 0, "check code alignment"); 482 // Change jumps before doing the copying; this routine requires aligned switches. 483 change_jumps(bci, delta); 484 485 // In case we have shrunken a tableswitch/lookupswitch statement, we store the last 486 // bytes that get overwritten. We have to copy the bytes after the change_jumps method 487 // has been called, since it is likly to update last offset in a tableswitch/lookupswitch 488 if (delta < 0) { 489 assert(delta>=-3, "we cannot overwrite more than 3 bytes"); 490 memcpy(_overwrite, addr_at(bci + ilen + delta), -delta); 491 } 492 493 memmove(addr_at(next_bci + delta), addr_at(next_bci), code_length() - next_bci); 494 set_code_length(code_length() + delta); 495 // Also adjust exception tables... 496 adjust_exception_table(bci, delta); 497 // Line number tables... 498 adjust_line_no_table(bci, delta); 499 // And local variable table... 500 adjust_local_var_table(bci, delta); 501 502 // Relocate the pending change stack... 503 for (int j = 0; j < _changes->length(); j++) { 504 ChangeItem* ci = _changes->at(j); 505 ci->relocate(bci, delta); 506 } 507 508 // Notify any listeners about code relocation 509 notify(bci, delta, code_length()); 510 511 return true; 512} 513 514// relocate a general instruction. Called by ChangeWiden class 515bool Relocator::handle_widen(int bci, int new_ilen, u_char inst_buffer[]) { 516 int ilen = rc_instr_len(bci); 517 if (!relocate_code(bci, ilen, new_ilen - ilen)) 518 return false; 519 520 // Insert new bytecode(s) 521 for(int k = 0; k < new_ilen; k++) { 522 code_at_put(bci + k, (Bytecodes::Code)inst_buffer[k]); 523 } 524 525 return true; 526} 527 528// handle jump_widen instruction. Called be ChangeJumpWiden class 529bool Relocator::handle_jump_widen(int bci, int delta) { 530 int ilen = rc_instr_len(bci); 531 532 Bytecodes::Code bc = code_at(bci); 533 switch (bc) { 534 case Bytecodes::_ifeq: 535 case Bytecodes::_ifne: 536 case Bytecodes::_iflt: 537 case Bytecodes::_ifge: 538 case Bytecodes::_ifgt: 539 case Bytecodes::_ifle: 540 case Bytecodes::_if_icmpeq: 541 case Bytecodes::_if_icmpne: 542 case Bytecodes::_if_icmplt: 543 case Bytecodes::_if_icmpge: 544 case Bytecodes::_if_icmpgt: 545 case Bytecodes::_if_icmple: 546 case Bytecodes::_if_acmpeq: 547 case Bytecodes::_if_acmpne: 548 case Bytecodes::_ifnull: 549 case Bytecodes::_ifnonnull: { 550 const int goto_length = Bytecodes::length_for(Bytecodes::_goto); 551 552 // If 'if' points to the next bytecode after goto, it's already handled. 553 // it shouldn't be. 554 assert (short_at(bci+1) != ilen+goto_length, "if relocation already handled"); 555 assert(ilen == 3, "check length"); 556 557 // Convert to 0 if <cond> goto 6 558 // 3 _goto 11 559 // 6 _goto_w <wide delta offset> 560 // 11 <else code> 561 const int goto_w_length = Bytecodes::length_for(Bytecodes::_goto_w); 562 const int add_bci = goto_length + goto_w_length; 563 564 if (!relocate_code(bci, 3, /*delta*/add_bci)) return false; 565 566 // if bytecode points to goto_w instruction 567 short_at_put(bci + 1, ilen + goto_length); 568 569 int cbci = bci + ilen; 570 // goto around 571 code_at_put(cbci, Bytecodes::_goto); 572 short_at_put(cbci + 1, add_bci); 573 // goto_w <wide delta> 574 cbci = cbci + goto_length; 575 code_at_put(cbci, Bytecodes::_goto_w); 576 if (delta > 0) { 577 delta += 2; // goto_w is 2 bytes more than "if" code 578 } else { 579 delta -= ilen+goto_length; // branch starts at goto_w offset 580 } 581 int_at_put(cbci + 1, delta); 582 break; 583 584 } 585 case Bytecodes::_goto: 586 case Bytecodes::_jsr: 587 assert(ilen == 3, "check length"); 588 589 if (!relocate_code(bci, 3, 2)) return false; 590 if (bc == Bytecodes::_goto) 591 code_at_put(bci, Bytecodes::_goto_w); 592 else 593 code_at_put(bci, Bytecodes::_jsr_w); 594 595 // If it's a forward jump, add 2 for the widening. 596 if (delta > 0) delta += 2; 597 int_at_put(bci + 1, delta); 598 break; 599 600 default: ShouldNotReachHere(); 601 } 602 603 return true; 604} 605 606// handle lookup/table switch instructions. Called be ChangeSwitchPad class 607bool Relocator::handle_switch_pad(int bci, int old_pad, bool is_lookup_switch) { 608 int ilen = rc_instr_len(bci); 609 int new_pad = align(bci+1) - (bci+1); 610 int pad_delta = new_pad - old_pad; 611 if (pad_delta != 0) { 612 int len; 613 if (!is_lookup_switch) { 614 int low = int_at(bci+1+old_pad+4); 615 int high = int_at(bci+1+old_pad+8); 616 len = high-low+1 + 3; // 3 for default, hi, lo. 617 } else { 618 int npairs = int_at(bci+1+old_pad+4); 619 len = npairs*2 + 2; // 2 for default, npairs. 620 } 621 // Because "relocateCode" does a "changeJumps" loop, 622 // which parses instructions to determine their length, 623 // we need to call that before messing with the current 624 // instruction. Since it may also overwrite the current 625 // instruction when moving down, remember the possibly 626 // overwritten part. 627 628 // Move the code following the instruction... 629 if (!relocate_code(bci, ilen, pad_delta)) return false; 630 631 if (pad_delta < 0) { 632 // Move the shrunken instruction down. 633 memmove(addr_at(bci + 1 + new_pad), 634 addr_at(bci + 1 + old_pad), 635 len * 4 + pad_delta); 636 memmove(addr_at(bci + 1 + new_pad + len*4 + pad_delta), 637 _overwrite, -pad_delta); 638 } else { 639 assert(pad_delta > 0, "check"); 640 // Move the expanded instruction up. 641 memmove(addr_at(bci +1 + new_pad), 642 addr_at(bci +1 + old_pad), 643 len * 4); 644 } 645 } 646 return true; 647} 648