1 /* 2 * Copyright (c) 2003, 2013, 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 "precompiled.hpp" 26 #include "classfile/metadataOnStackMark.hpp" 27 #include "classfile/systemDictionary.hpp" 28 #include "classfile/verifier.hpp" 29 #include "code/codeCache.hpp" 30 #include "compiler/compileBroker.hpp" 31 #include "interpreter/oopMapCache.hpp" 32 #include "interpreter/rewriter.hpp" 33 #include "memory/gcLocker.hpp" 34 #include "memory/metadataFactory.hpp" 35 #include "memory/metaspaceShared.hpp" 36 #include "memory/universe.inline.hpp" 37 #include "oops/fieldStreams.hpp" 38 #include "oops/klassVtable.hpp" 39 #include "prims/jvmtiImpl.hpp" 40 #include "prims/jvmtiRedefineClasses.hpp" 41 #include "prims/methodComparator.hpp" 42 #include "runtime/deoptimization.hpp" 43 #include "runtime/relocator.hpp" 44 #include "utilities/bitMap.inline.hpp" 45 46 47 Array<Method*>* VM_RedefineClasses::_old_methods = NULL; 48 Array<Method*>* VM_RedefineClasses::_new_methods = NULL; 49 Method** VM_RedefineClasses::_matching_old_methods = NULL; 50 Method** VM_RedefineClasses::_matching_new_methods = NULL; 51 Method** VM_RedefineClasses::_deleted_methods = NULL; 52 Method** VM_RedefineClasses::_added_methods = NULL; 53 int VM_RedefineClasses::_matching_methods_length = 0; 54 int VM_RedefineClasses::_deleted_methods_length = 0; 55 int VM_RedefineClasses::_added_methods_length = 0; 56 Klass* VM_RedefineClasses::_the_class_oop = NULL; 57 58 59 VM_RedefineClasses::VM_RedefineClasses(jint class_count, 60 const jvmtiClassDefinition *class_defs, 61 JvmtiClassLoadKind class_load_kind) { 62 _class_count = class_count; 63 _class_defs = class_defs; 64 _class_load_kind = class_load_kind; 65 _res = JVMTI_ERROR_NONE; 66 } 67 68 bool VM_RedefineClasses::doit_prologue() { 69 if (_class_count == 0) { 70 _res = JVMTI_ERROR_NONE; 71 return false; 72 } 73 if (_class_defs == NULL) { 74 _res = JVMTI_ERROR_NULL_POINTER; 75 return false; 76 } 77 for (int i = 0; i < _class_count; i++) { 78 if (_class_defs[i].klass == NULL) { 79 _res = JVMTI_ERROR_INVALID_CLASS; 80 return false; 81 } 82 if (_class_defs[i].class_byte_count == 0) { 83 _res = JVMTI_ERROR_INVALID_CLASS_FORMAT; 84 return false; 85 } 86 if (_class_defs[i].class_bytes == NULL) { 87 _res = JVMTI_ERROR_NULL_POINTER; 88 return false; 89 } 90 } 91 92 // Start timer after all the sanity checks; not quite accurate, but 93 // better than adding a bunch of stop() calls. 94 RC_TIMER_START(_timer_vm_op_prologue); 95 96 // We first load new class versions in the prologue, because somewhere down the 97 // call chain it is required that the current thread is a Java thread. 98 _res = load_new_class_versions(Thread::current()); 99 if (_res != JVMTI_ERROR_NONE) { 100 // free any successfully created classes, since none are redefined 101 for (int i = 0; i < _class_count; i++) { 102 if (_scratch_classes[i] != NULL) { 103 ClassLoaderData* cld = _scratch_classes[i]->class_loader_data(); 104 // Free the memory for this class at class unloading time. Not before 105 // because CMS might think this is still live. 106 cld->add_to_deallocate_list((InstanceKlass*)_scratch_classes[i]); 107 } 108 } 109 // Free os::malloc allocated memory in load_new_class_version. 110 os::free(_scratch_classes); 111 RC_TIMER_STOP(_timer_vm_op_prologue); 112 return false; 113 } 114 115 RC_TIMER_STOP(_timer_vm_op_prologue); 116 return true; 117 } 118 119 void VM_RedefineClasses::doit() { 120 Thread *thread = Thread::current(); 121 122 if (UseSharedSpaces) { 123 // Sharing is enabled so we remap the shared readonly space to 124 // shared readwrite, private just in case we need to redefine 125 // a shared class. We do the remap during the doit() phase of 126 // the safepoint to be safer. 127 if (!MetaspaceShared::remap_shared_readonly_as_readwrite()) { 128 RC_TRACE_WITH_THREAD(0x00000001, thread, 129 ("failed to remap shared readonly space to readwrite, private")); 130 _res = JVMTI_ERROR_INTERNAL; 131 return; 132 } 133 } 134 135 // Mark methods seen on stack and everywhere else so old methods are not 136 // cleaned up if they're on the stack. 137 MetadataOnStackMark md_on_stack; 138 HandleMark hm(thread); // make sure any handles created are deleted 139 // before the stack walk again. 140 141 for (int i = 0; i < _class_count; i++) { 142 redefine_single_class(_class_defs[i].klass, _scratch_classes[i], thread); 143 ClassLoaderData* cld = _scratch_classes[i]->class_loader_data(); 144 // Free the memory for this class at class unloading time. Not before 145 // because CMS might think this is still live. 146 cld->add_to_deallocate_list((InstanceKlass*)_scratch_classes[i]); 147 _scratch_classes[i] = NULL; 148 } 149 150 // Disable any dependent concurrent compilations 151 SystemDictionary::notice_modification(); 152 153 // Set flag indicating that some invariants are no longer true. 154 // See jvmtiExport.hpp for detailed explanation. 155 JvmtiExport::set_has_redefined_a_class(); 156 157 // check_class() is optionally called for product bits, but is 158 // always called for non-product bits. 159 #ifdef PRODUCT 160 if (RC_TRACE_ENABLED(0x00004000)) { 161 #endif 162 RC_TRACE_WITH_THREAD(0x00004000, thread, ("calling check_class")); 163 SystemDictionary::classes_do(check_class, thread); 164 #ifdef PRODUCT 165 } 166 #endif 167 } 168 169 void VM_RedefineClasses::doit_epilogue() { 170 // Free os::malloc allocated memory. 171 os::free(_scratch_classes); 172 173 if (RC_TRACE_ENABLED(0x00000004)) { 174 // Used to have separate timers for "doit" and "all", but the timer 175 // overhead skewed the measurements. 176 jlong doit_time = _timer_rsc_phase1.milliseconds() + 177 _timer_rsc_phase2.milliseconds(); 178 jlong all_time = _timer_vm_op_prologue.milliseconds() + doit_time; 179 180 RC_TRACE(0x00000004, ("vm_op: all=" UINT64_FORMAT 181 " prologue=" UINT64_FORMAT " doit=" UINT64_FORMAT, all_time, 182 _timer_vm_op_prologue.milliseconds(), doit_time)); 183 RC_TRACE(0x00000004, 184 ("redefine_single_class: phase1=" UINT64_FORMAT " phase2=" UINT64_FORMAT, 185 _timer_rsc_phase1.milliseconds(), _timer_rsc_phase2.milliseconds())); 186 } 187 } 188 189 bool VM_RedefineClasses::is_modifiable_class(oop klass_mirror) { 190 // classes for primitives cannot be redefined 191 if (java_lang_Class::is_primitive(klass_mirror)) { 192 return false; 193 } 194 Klass* the_class_oop = java_lang_Class::as_Klass(klass_mirror); 195 // classes for arrays cannot be redefined 196 if (the_class_oop == NULL || !the_class_oop->oop_is_instance()) { 197 return false; 198 } 199 return true; 200 } 201 202 // Append the current entry at scratch_i in scratch_cp to *merge_cp_p 203 // where the end of *merge_cp_p is specified by *merge_cp_length_p. For 204 // direct CP entries, there is just the current entry to append. For 205 // indirect and double-indirect CP entries, there are zero or more 206 // referenced CP entries along with the current entry to append. 207 // Indirect and double-indirect CP entries are handled by recursive 208 // calls to append_entry() as needed. The referenced CP entries are 209 // always appended to *merge_cp_p before the referee CP entry. These 210 // referenced CP entries may already exist in *merge_cp_p in which case 211 // there is nothing extra to append and only the current entry is 212 // appended. 213 void VM_RedefineClasses::append_entry(constantPoolHandle scratch_cp, 214 int scratch_i, constantPoolHandle *merge_cp_p, int *merge_cp_length_p, 215 TRAPS) { 216 217 // append is different depending on entry tag type 218 switch (scratch_cp->tag_at(scratch_i).value()) { 219 220 // The old verifier is implemented outside the VM. It loads classes, 221 // but does not resolve constant pool entries directly so we never 222 // see Class entries here with the old verifier. Similarly the old 223 // verifier does not like Class entries in the input constant pool. 224 // The split-verifier is implemented in the VM so it can optionally 225 // and directly resolve constant pool entries to load classes. The 226 // split-verifier can accept either Class entries or UnresolvedClass 227 // entries in the input constant pool. We revert the appended copy 228 // back to UnresolvedClass so that either verifier will be happy 229 // with the constant pool entry. 230 case JVM_CONSTANT_Class: 231 { 232 // revert the copy to JVM_CONSTANT_UnresolvedClass 233 (*merge_cp_p)->unresolved_klass_at_put(*merge_cp_length_p, 234 scratch_cp->klass_name_at(scratch_i)); 235 236 if (scratch_i != *merge_cp_length_p) { 237 // The new entry in *merge_cp_p is at a different index than 238 // the new entry in scratch_cp so we need to map the index values. 239 map_index(scratch_cp, scratch_i, *merge_cp_length_p); 240 } 241 (*merge_cp_length_p)++; 242 } break; 243 244 // these are direct CP entries so they can be directly appended, 245 // but double and long take two constant pool entries 246 case JVM_CONSTANT_Double: // fall through 247 case JVM_CONSTANT_Long: 248 { 249 ConstantPool::copy_entry_to(scratch_cp, scratch_i, *merge_cp_p, *merge_cp_length_p, 250 THREAD); 251 252 if (scratch_i != *merge_cp_length_p) { 253 // The new entry in *merge_cp_p is at a different index than 254 // the new entry in scratch_cp so we need to map the index values. 255 map_index(scratch_cp, scratch_i, *merge_cp_length_p); 256 } 257 (*merge_cp_length_p) += 2; 258 } break; 259 260 // these are direct CP entries so they can be directly appended 261 case JVM_CONSTANT_Float: // fall through 262 case JVM_CONSTANT_Integer: // fall through 263 case JVM_CONSTANT_Utf8: // fall through 264 265 // This was an indirect CP entry, but it has been changed into 266 // Symbol*s so this entry can be directly appended. 267 case JVM_CONSTANT_String: // fall through 268 269 // These were indirect CP entries, but they have been changed into 270 // Symbol*s so these entries can be directly appended. 271 case JVM_CONSTANT_UnresolvedClass: // fall through 272 { 273 ConstantPool::copy_entry_to(scratch_cp, scratch_i, *merge_cp_p, *merge_cp_length_p, 274 THREAD); 275 276 if (scratch_i != *merge_cp_length_p) { 277 // The new entry in *merge_cp_p is at a different index than 278 // the new entry in scratch_cp so we need to map the index values. 279 map_index(scratch_cp, scratch_i, *merge_cp_length_p); 280 } 281 (*merge_cp_length_p)++; 282 } break; 283 284 // this is an indirect CP entry so it needs special handling 285 case JVM_CONSTANT_NameAndType: 286 { 287 int name_ref_i = scratch_cp->name_ref_index_at(scratch_i); 288 int new_name_ref_i = find_or_append_indirect_entry(scratch_cp, name_ref_i, merge_cp_p, 289 merge_cp_length_p, THREAD); 290 291 int signature_ref_i = scratch_cp->signature_ref_index_at(scratch_i); 292 int new_signature_ref_i = find_or_append_indirect_entry(scratch_cp, signature_ref_i, 293 merge_cp_p, merge_cp_length_p, 294 THREAD); 295 296 // If the referenced entries already exist in *merge_cp_p, then 297 // both new_name_ref_i and new_signature_ref_i will both be 0. 298 // In that case, all we are appending is the current entry. 299 if (new_name_ref_i != name_ref_i) { 300 RC_TRACE(0x00080000, 301 ("NameAndType entry@%d name_ref_index change: %d to %d", 302 *merge_cp_length_p, name_ref_i, new_name_ref_i)); 303 } 304 if (new_signature_ref_i != signature_ref_i) { 305 RC_TRACE(0x00080000, 306 ("NameAndType entry@%d signature_ref_index change: %d to %d", 307 *merge_cp_length_p, signature_ref_i, new_signature_ref_i)); 308 } 309 310 (*merge_cp_p)->name_and_type_at_put(*merge_cp_length_p, 311 new_name_ref_i, new_signature_ref_i); 312 if (scratch_i != *merge_cp_length_p) { 313 // The new entry in *merge_cp_p is at a different index than 314 // the new entry in scratch_cp so we need to map the index values. 315 map_index(scratch_cp, scratch_i, *merge_cp_length_p); 316 } 317 (*merge_cp_length_p)++; 318 } break; 319 320 // this is a double-indirect CP entry so it needs special handling 321 case JVM_CONSTANT_Fieldref: // fall through 322 case JVM_CONSTANT_InterfaceMethodref: // fall through 323 case JVM_CONSTANT_Methodref: 324 { 325 int klass_ref_i = scratch_cp->uncached_klass_ref_index_at(scratch_i); 326 int new_klass_ref_i = find_or_append_indirect_entry(scratch_cp, klass_ref_i, 327 merge_cp_p, merge_cp_length_p, THREAD); 328 329 int name_and_type_ref_i = scratch_cp->uncached_name_and_type_ref_index_at(scratch_i); 330 int new_name_and_type_ref_i = find_or_append_indirect_entry(scratch_cp, name_and_type_ref_i, 331 merge_cp_p, merge_cp_length_p, THREAD); 332 333 const char *entry_name; 334 switch (scratch_cp->tag_at(scratch_i).value()) { 335 case JVM_CONSTANT_Fieldref: 336 entry_name = "Fieldref"; 337 (*merge_cp_p)->field_at_put(*merge_cp_length_p, new_klass_ref_i, 338 new_name_and_type_ref_i); 339 break; 340 case JVM_CONSTANT_InterfaceMethodref: 341 entry_name = "IFMethodref"; 342 (*merge_cp_p)->interface_method_at_put(*merge_cp_length_p, 343 new_klass_ref_i, new_name_and_type_ref_i); 344 break; 345 case JVM_CONSTANT_Methodref: 346 entry_name = "Methodref"; 347 (*merge_cp_p)->method_at_put(*merge_cp_length_p, new_klass_ref_i, 348 new_name_and_type_ref_i); 349 break; 350 default: 351 guarantee(false, "bad switch"); 352 break; 353 } 354 355 if (klass_ref_i != new_klass_ref_i) { 356 RC_TRACE(0x00080000, ("%s entry@%d class_index changed: %d to %d", 357 entry_name, *merge_cp_length_p, klass_ref_i, new_klass_ref_i)); 358 } 359 if (name_and_type_ref_i != new_name_and_type_ref_i) { 360 RC_TRACE(0x00080000, 361 ("%s entry@%d name_and_type_index changed: %d to %d", 362 entry_name, *merge_cp_length_p, name_and_type_ref_i, 363 new_name_and_type_ref_i)); 364 } 365 366 if (scratch_i != *merge_cp_length_p) { 367 // The new entry in *merge_cp_p is at a different index than 368 // the new entry in scratch_cp so we need to map the index values. 369 map_index(scratch_cp, scratch_i, *merge_cp_length_p); 370 } 371 (*merge_cp_length_p)++; 372 } break; 373 374 // this is an indirect CP entry so it needs special handling 375 case JVM_CONSTANT_MethodType: 376 { 377 int ref_i = scratch_cp->method_type_index_at(scratch_i); 378 int new_ref_i = find_or_append_indirect_entry(scratch_cp, ref_i, merge_cp_p, 379 merge_cp_length_p, THREAD); 380 if (new_ref_i != ref_i) { 381 RC_TRACE(0x00080000, 382 ("MethodType entry@%d ref_index change: %d to %d", 383 *merge_cp_length_p, ref_i, new_ref_i)); 384 } 385 (*merge_cp_p)->method_type_index_at_put(*merge_cp_length_p, new_ref_i); 386 if (scratch_i != *merge_cp_length_p) { 387 // The new entry in *merge_cp_p is at a different index than 388 // the new entry in scratch_cp so we need to map the index values. 389 map_index(scratch_cp, scratch_i, *merge_cp_length_p); 390 } 391 (*merge_cp_length_p)++; 392 } break; 393 394 // this is an indirect CP entry so it needs special handling 395 case JVM_CONSTANT_MethodHandle: 396 { 397 int ref_kind = scratch_cp->method_handle_ref_kind_at(scratch_i); 398 int ref_i = scratch_cp->method_handle_index_at(scratch_i); 399 int new_ref_i = find_or_append_indirect_entry(scratch_cp, ref_i, merge_cp_p, 400 merge_cp_length_p, THREAD); 401 if (new_ref_i != ref_i) { 402 RC_TRACE(0x00080000, 403 ("MethodHandle entry@%d ref_index change: %d to %d", 404 *merge_cp_length_p, ref_i, new_ref_i)); 405 } 406 (*merge_cp_p)->method_handle_index_at_put(*merge_cp_length_p, ref_kind, new_ref_i); 407 if (scratch_i != *merge_cp_length_p) { 408 // The new entry in *merge_cp_p is at a different index than 409 // the new entry in scratch_cp so we need to map the index values. 410 map_index(scratch_cp, scratch_i, *merge_cp_length_p); 411 } 412 (*merge_cp_length_p)++; 413 } break; 414 415 // this is an indirect CP entry so it needs special handling 416 case JVM_CONSTANT_InvokeDynamic: 417 { 418 // Index of the bootstrap specifier in the operands array 419 int old_bs_i = scratch_cp->invoke_dynamic_bootstrap_specifier_index(scratch_i); 420 int new_bs_i = find_or_append_operand(scratch_cp, old_bs_i, merge_cp_p, 421 merge_cp_length_p, THREAD); 422 // The bootstrap method NameAndType_info index 423 int old_ref_i = scratch_cp->invoke_dynamic_name_and_type_ref_index_at(scratch_i); 424 int new_ref_i = find_or_append_indirect_entry(scratch_cp, old_ref_i, merge_cp_p, 425 merge_cp_length_p, THREAD); 426 if (new_bs_i != old_bs_i) { 427 RC_TRACE(0x00080000, 428 ("InvokeDynamic entry@%d bootstrap_method_attr_index change: %d to %d", 429 *merge_cp_length_p, old_bs_i, new_bs_i)); 430 } 431 if (new_ref_i != old_ref_i) { 432 RC_TRACE(0x00080000, 433 ("InvokeDynamic entry@%d name_and_type_index change: %d to %d", 434 *merge_cp_length_p, old_ref_i, new_ref_i)); 435 } 436 437 (*merge_cp_p)->invoke_dynamic_at_put(*merge_cp_length_p, new_bs_i, new_ref_i); 438 if (scratch_i != *merge_cp_length_p) { 439 // The new entry in *merge_cp_p is at a different index than 440 // the new entry in scratch_cp so we need to map the index values. 441 map_index(scratch_cp, scratch_i, *merge_cp_length_p); 442 } 443 (*merge_cp_length_p)++; 444 } break; 445 446 // At this stage, Class or UnresolvedClass could be here, but not 447 // ClassIndex 448 case JVM_CONSTANT_ClassIndex: // fall through 449 450 // Invalid is used as the tag for the second constant pool entry 451 // occupied by JVM_CONSTANT_Double or JVM_CONSTANT_Long. It should 452 // not be seen by itself. 453 case JVM_CONSTANT_Invalid: // fall through 454 455 // At this stage, String could be here, but not StringIndex 456 case JVM_CONSTANT_StringIndex: // fall through 457 458 // At this stage JVM_CONSTANT_UnresolvedClassInError should not be 459 // here 460 case JVM_CONSTANT_UnresolvedClassInError: // fall through 461 462 default: 463 { 464 // leave a breadcrumb 465 jbyte bad_value = scratch_cp->tag_at(scratch_i).value(); 466 ShouldNotReachHere(); 467 } break; 468 } // end switch tag value 469 } // end append_entry() 470 471 472 int VM_RedefineClasses::find_or_append_indirect_entry(constantPoolHandle scratch_cp, 473 int ref_i, constantPoolHandle *merge_cp_p, int *merge_cp_length_p, TRAPS) { 474 475 int new_ref_i = ref_i; 476 bool match = (ref_i < *merge_cp_length_p) && 477 scratch_cp->compare_entry_to(ref_i, *merge_cp_p, ref_i, THREAD); 478 479 if (!match) { 480 // forward reference in *merge_cp_p or not a direct match 481 int found_i = scratch_cp->find_matching_entry(ref_i, *merge_cp_p, THREAD); 482 if (found_i != 0) { 483 guarantee(found_i != ref_i, "compare_entry_to() and find_matching_entry() do not agree"); 484 // Found a matching entry somewhere else in *merge_cp_p so just need a mapping entry. 485 new_ref_i = found_i; 486 map_index(scratch_cp, ref_i, found_i); 487 } else { 488 // no match found so we have to append this entry to *merge_cp_p 489 append_entry(scratch_cp, ref_i, merge_cp_p, merge_cp_length_p, THREAD); 490 // The above call to append_entry() can only append one entry 491 // so the post call query of *merge_cp_length_p is only for 492 // the sake of consistency. 493 new_ref_i = *merge_cp_length_p - 1; 494 } 495 } 496 497 return new_ref_i; 498 } // end find_or_append_indirect_entry() 499 500 501 // Append a bootstrap specifier into the merge_cp operands that is semantically equal 502 // to the scratch_cp operands bootstrap specifier passed by the old_bs_i index. 503 // Recursively append new merge_cp entries referenced by the new bootstrap specifier. 504 void VM_RedefineClasses::append_operand(constantPoolHandle scratch_cp, int old_bs_i, 505 constantPoolHandle *merge_cp_p, int *merge_cp_length_p, TRAPS) { 506 507 int old_ref_i = scratch_cp->operand_bootstrap_method_ref_index_at(old_bs_i); 508 int new_ref_i = find_or_append_indirect_entry(scratch_cp, old_ref_i, merge_cp_p, 509 merge_cp_length_p, THREAD); 510 if (new_ref_i != old_ref_i) { 511 RC_TRACE(0x00080000, 512 ("operands entry@%d bootstrap method ref_index change: %d to %d", 513 _operands_cur_length, old_ref_i, new_ref_i)); 514 } 515 516 Array<u2>* merge_ops = (*merge_cp_p)->operands(); 517 int new_bs_i = _operands_cur_length; 518 // We have _operands_cur_length == 0 when the merge_cp operands is empty yet. 519 // However, the operand_offset_at(0) was set in the extend_operands() call. 520 int new_base = (new_bs_i == 0) ? (*merge_cp_p)->operand_offset_at(0) 521 : (*merge_cp_p)->operand_next_offset_at(new_bs_i - 1); 522 int argc = scratch_cp->operand_argument_count_at(old_bs_i); 523 524 ConstantPool::operand_offset_at_put(merge_ops, _operands_cur_length, new_base); 525 merge_ops->at_put(new_base++, new_ref_i); 526 merge_ops->at_put(new_base++, argc); 527 528 for (int i = 0; i < argc; i++) { 529 int old_arg_ref_i = scratch_cp->operand_argument_index_at(old_bs_i, i); 530 int new_arg_ref_i = find_or_append_indirect_entry(scratch_cp, old_arg_ref_i, merge_cp_p, 531 merge_cp_length_p, THREAD); 532 merge_ops->at_put(new_base++, new_arg_ref_i); 533 if (new_arg_ref_i != old_arg_ref_i) { 534 RC_TRACE(0x00080000, 535 ("operands entry@%d bootstrap method argument ref_index change: %d to %d", 536 _operands_cur_length, old_arg_ref_i, new_arg_ref_i)); 537 } 538 } 539 if (old_bs_i != _operands_cur_length) { 540 // The bootstrap specifier in *merge_cp_p is at a different index than 541 // that in scratch_cp so we need to map the index values. 542 map_operand_index(old_bs_i, new_bs_i); 543 } 544 _operands_cur_length++; 545 } // end append_operand() 546 547 548 int VM_RedefineClasses::find_or_append_operand(constantPoolHandle scratch_cp, 549 int old_bs_i, constantPoolHandle *merge_cp_p, int *merge_cp_length_p, TRAPS) { 550 551 int new_bs_i = old_bs_i; // bootstrap specifier index 552 bool match = (old_bs_i < _operands_cur_length) && 553 scratch_cp->compare_operand_to(old_bs_i, *merge_cp_p, old_bs_i, THREAD); 554 555 if (!match) { 556 // forward reference in *merge_cp_p or not a direct match 557 int found_i = scratch_cp->find_matching_operand(old_bs_i, *merge_cp_p, 558 _operands_cur_length, THREAD); 559 if (found_i != -1) { 560 guarantee(found_i != old_bs_i, "compare_operand_to() and find_matching_operand() disagree"); 561 // found a matching operand somewhere else in *merge_cp_p so just need a mapping 562 new_bs_i = found_i; 563 map_operand_index(old_bs_i, found_i); 564 } else { 565 // no match found so we have to append this bootstrap specifier to *merge_cp_p 566 append_operand(scratch_cp, old_bs_i, merge_cp_p, merge_cp_length_p, THREAD); 567 new_bs_i = _operands_cur_length - 1; 568 } 569 } 570 return new_bs_i; 571 } // end find_or_append_operand() 572 573 574 void VM_RedefineClasses::finalize_operands_merge(constantPoolHandle merge_cp, TRAPS) { 575 if (merge_cp->operands() == NULL) { 576 return; 577 } 578 // Shrink the merge_cp operands 579 merge_cp->shrink_operands(_operands_cur_length, CHECK); 580 581 if (RC_TRACE_ENABLED(0x00040000)) { 582 // don't want to loop unless we are tracing 583 int count = 0; 584 for (int i = 1; i < _operands_index_map_p->length(); i++) { 585 int value = _operands_index_map_p->at(i); 586 if (value != -1) { 587 RC_TRACE_WITH_THREAD(0x00040000, THREAD, 588 ("operands_index_map[%d]: old=%d new=%d", count, i, value)); 589 count++; 590 } 591 } 592 } 593 // Clean-up 594 _operands_index_map_p = NULL; 595 _operands_cur_length = 0; 596 _operands_index_map_count = 0; 597 } // end finalize_operands_merge() 598 599 600 jvmtiError VM_RedefineClasses::compare_and_normalize_class_versions( 601 instanceKlassHandle the_class, 602 instanceKlassHandle scratch_class) { 603 int i; 604 605 // Check superclasses, or rather their names, since superclasses themselves can be 606 // requested to replace. 607 // Check for NULL superclass first since this might be java.lang.Object 608 if (the_class->super() != scratch_class->super() && 609 (the_class->super() == NULL || scratch_class->super() == NULL || 610 the_class->super()->name() != 611 scratch_class->super()->name())) { 612 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED; 613 } 614 615 // Check if the number, names and order of directly implemented interfaces are the same. 616 // I think in principle we should just check if the sets of names of directly implemented 617 // interfaces are the same, i.e. the order of declaration (which, however, if changed in the 618 // .java file, also changes in .class file) should not matter. However, comparing sets is 619 // technically a bit more difficult, and, more importantly, I am not sure at present that the 620 // order of interfaces does not matter on the implementation level, i.e. that the VM does not 621 // rely on it somewhere. 622 Array<Klass*>* k_interfaces = the_class->local_interfaces(); 623 Array<Klass*>* k_new_interfaces = scratch_class->local_interfaces(); 624 int n_intfs = k_interfaces->length(); 625 if (n_intfs != k_new_interfaces->length()) { 626 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED; 627 } 628 for (i = 0; i < n_intfs; i++) { 629 if (k_interfaces->at(i)->name() != 630 k_new_interfaces->at(i)->name()) { 631 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED; 632 } 633 } 634 635 // Check whether class is in the error init state. 636 if (the_class->is_in_error_state()) { 637 // TBD #5057930: special error code is needed in 1.6 638 return JVMTI_ERROR_INVALID_CLASS; 639 } 640 641 // Check whether class modifiers are the same. 642 jushort old_flags = (jushort) the_class->access_flags().get_flags(); 643 jushort new_flags = (jushort) scratch_class->access_flags().get_flags(); 644 if (old_flags != new_flags) { 645 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED; 646 } 647 648 // Check if the number, names, types and order of fields declared in these classes 649 // are the same. 650 JavaFieldStream old_fs(the_class); 651 JavaFieldStream new_fs(scratch_class); 652 for (; !old_fs.done() && !new_fs.done(); old_fs.next(), new_fs.next()) { 653 // access 654 old_flags = old_fs.access_flags().as_short(); 655 new_flags = new_fs.access_flags().as_short(); 656 if ((old_flags ^ new_flags) & JVM_RECOGNIZED_FIELD_MODIFIERS) { 657 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED; 658 } 659 // offset 660 if (old_fs.offset() != new_fs.offset()) { 661 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED; 662 } 663 // name and signature 664 Symbol* name_sym1 = the_class->constants()->symbol_at(old_fs.name_index()); 665 Symbol* sig_sym1 = the_class->constants()->symbol_at(old_fs.signature_index()); 666 Symbol* name_sym2 = scratch_class->constants()->symbol_at(new_fs.name_index()); 667 Symbol* sig_sym2 = scratch_class->constants()->symbol_at(new_fs.signature_index()); 668 if (name_sym1 != name_sym2 || sig_sym1 != sig_sym2) { 669 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED; 670 } 671 } 672 673 // If both streams aren't done then we have a differing number of 674 // fields. 675 if (!old_fs.done() || !new_fs.done()) { 676 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED; 677 } 678 679 // Do a parallel walk through the old and new methods. Detect 680 // cases where they match (exist in both), have been added in 681 // the new methods, or have been deleted (exist only in the 682 // old methods). The class file parser places methods in order 683 // by method name, but does not order overloaded methods by 684 // signature. In order to determine what fate befell the methods, 685 // this code places the overloaded new methods that have matching 686 // old methods in the same order as the old methods and places 687 // new overloaded methods at the end of overloaded methods of 688 // that name. The code for this order normalization is adapted 689 // from the algorithm used in InstanceKlass::find_method(). 690 // Since we are swapping out of order entries as we find them, 691 // we only have to search forward through the overloaded methods. 692 // Methods which are added and have the same name as an existing 693 // method (but different signature) will be put at the end of 694 // the methods with that name, and the name mismatch code will 695 // handle them. 696 Array<Method*>* k_old_methods(the_class->methods()); 697 Array<Method*>* k_new_methods(scratch_class->methods()); 698 int n_old_methods = k_old_methods->length(); 699 int n_new_methods = k_new_methods->length(); 700 Thread* thread = Thread::current(); 701 702 int ni = 0; 703 int oi = 0; 704 while (true) { 705 Method* k_old_method; 706 Method* k_new_method; 707 enum { matched, added, deleted, undetermined } method_was = undetermined; 708 709 if (oi >= n_old_methods) { 710 if (ni >= n_new_methods) { 711 break; // we've looked at everything, done 712 } 713 // New method at the end 714 k_new_method = k_new_methods->at(ni); 715 method_was = added; 716 } else if (ni >= n_new_methods) { 717 // Old method, at the end, is deleted 718 k_old_method = k_old_methods->at(oi); 719 method_was = deleted; 720 } else { 721 // There are more methods in both the old and new lists 722 k_old_method = k_old_methods->at(oi); 723 k_new_method = k_new_methods->at(ni); 724 if (k_old_method->name() != k_new_method->name()) { 725 // Methods are sorted by method name, so a mismatch means added 726 // or deleted 727 if (k_old_method->name()->fast_compare(k_new_method->name()) > 0) { 728 method_was = added; 729 } else { 730 method_was = deleted; 731 } 732 } else if (k_old_method->signature() == k_new_method->signature()) { 733 // Both the name and signature match 734 method_was = matched; 735 } else { 736 // The name matches, but the signature doesn't, which means we have to 737 // search forward through the new overloaded methods. 738 int nj; // outside the loop for post-loop check 739 for (nj = ni + 1; nj < n_new_methods; nj++) { 740 Method* m = k_new_methods->at(nj); 741 if (k_old_method->name() != m->name()) { 742 // reached another method name so no more overloaded methods 743 method_was = deleted; 744 break; 745 } 746 if (k_old_method->signature() == m->signature()) { 747 // found a match so swap the methods 748 k_new_methods->at_put(ni, m); 749 k_new_methods->at_put(nj, k_new_method); 750 k_new_method = m; 751 method_was = matched; 752 break; 753 } 754 } 755 756 if (nj >= n_new_methods) { 757 // reached the end without a match; so method was deleted 758 method_was = deleted; 759 } 760 } 761 } 762 763 switch (method_was) { 764 case matched: 765 // methods match, be sure modifiers do too 766 old_flags = (jushort) k_old_method->access_flags().get_flags(); 767 new_flags = (jushort) k_new_method->access_flags().get_flags(); 768 if ((old_flags ^ new_flags) & ~(JVM_ACC_NATIVE)) { 769 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED; 770 } 771 { 772 u2 new_num = k_new_method->method_idnum(); 773 u2 old_num = k_old_method->method_idnum(); 774 if (new_num != old_num) { 775 Method* idnum_owner = scratch_class->method_with_idnum(old_num); 776 if (idnum_owner != NULL) { 777 // There is already a method assigned this idnum -- switch them 778 idnum_owner->set_method_idnum(new_num); 779 } 780 k_new_method->set_method_idnum(old_num); 781 if (thread->has_pending_exception()) { 782 return JVMTI_ERROR_OUT_OF_MEMORY; 783 } 784 } 785 } 786 RC_TRACE(0x00008000, ("Method matched: new: %s [%d] == old: %s [%d]", 787 k_new_method->name_and_sig_as_C_string(), ni, 788 k_old_method->name_and_sig_as_C_string(), oi)); 789 // advance to next pair of methods 790 ++oi; 791 ++ni; 792 break; 793 case added: 794 // method added, see if it is OK 795 new_flags = (jushort) k_new_method->access_flags().get_flags(); 796 if ((new_flags & JVM_ACC_PRIVATE) == 0 797 // hack: private should be treated as final, but alas 798 || (new_flags & (JVM_ACC_FINAL|JVM_ACC_STATIC)) == 0 799 ) { 800 // new methods must be private 801 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED; 802 } 803 { 804 u2 num = the_class->next_method_idnum(); 805 if (num == ConstMethod::UNSET_IDNUM) { 806 // cannot add any more methods 807 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED; 808 } 809 u2 new_num = k_new_method->method_idnum(); 810 Method* idnum_owner = scratch_class->method_with_idnum(num); 811 if (idnum_owner != NULL) { 812 // There is already a method assigned this idnum -- switch them 813 idnum_owner->set_method_idnum(new_num); 814 } 815 k_new_method->set_method_idnum(num); 816 if (thread->has_pending_exception()) { 817 return JVMTI_ERROR_OUT_OF_MEMORY; 818 } 819 } 820 RC_TRACE(0x00008000, ("Method added: new: %s [%d]", 821 k_new_method->name_and_sig_as_C_string(), ni)); 822 ++ni; // advance to next new method 823 break; 824 case deleted: 825 // method deleted, see if it is OK 826 old_flags = (jushort) k_old_method->access_flags().get_flags(); 827 if ((old_flags & JVM_ACC_PRIVATE) == 0 828 // hack: private should be treated as final, but alas 829 || (old_flags & (JVM_ACC_FINAL|JVM_ACC_STATIC)) == 0 830 ) { 831 // deleted methods must be private 832 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED; 833 } 834 RC_TRACE(0x00008000, ("Method deleted: old: %s [%d]", 835 k_old_method->name_and_sig_as_C_string(), oi)); 836 ++oi; // advance to next old method 837 break; 838 default: 839 ShouldNotReachHere(); 840 } 841 } 842 843 return JVMTI_ERROR_NONE; 844 } 845 846 847 // Find new constant pool index value for old constant pool index value 848 // by seaching the index map. Returns zero (0) if there is no mapped 849 // value for the old constant pool index. 850 int VM_RedefineClasses::find_new_index(int old_index) { 851 if (_index_map_count == 0) { 852 // map is empty so nothing can be found 853 return 0; 854 } 855 856 if (old_index < 1 || old_index >= _index_map_p->length()) { 857 // The old_index is out of range so it is not mapped. This should 858 // not happen in regular constant pool merging use, but it can 859 // happen if a corrupt annotation is processed. 860 return 0; 861 } 862 863 int value = _index_map_p->at(old_index); 864 if (value == -1) { 865 // the old_index is not mapped 866 return 0; 867 } 868 869 return value; 870 } // end find_new_index() 871 872 873 // Find new bootstrap specifier index value for old bootstrap specifier index 874 // value by seaching the index map. Returns zero (-1) if there is no mapped 875 // value for the old bootstrap specifier index. 876 int VM_RedefineClasses::find_new_operand_index(int old_index) { 877 if (_operands_index_map_count == 0) { 878 // map is empty so nothing can be found 879 return -1; 880 } 881 882 if (old_index == -1 || old_index >= _operands_index_map_p->length()) { 883 // The old_index is out of range so it is not mapped. 884 // This should not happen in regular constant pool merging use. 885 return -1; 886 } 887 888 int value = _operands_index_map_p->at(old_index); 889 if (value == -1) { 890 // the old_index is not mapped 891 return -1; 892 } 893 894 return value; 895 } // end find_new_operand_index() 896 897 898 // Returns true if the current mismatch is due to a resolved/unresolved 899 // class pair. Otherwise, returns false. 900 bool VM_RedefineClasses::is_unresolved_class_mismatch(constantPoolHandle cp1, 901 int index1, constantPoolHandle cp2, int index2) { 902 903 jbyte t1 = cp1->tag_at(index1).value(); 904 if (t1 != JVM_CONSTANT_Class && t1 != JVM_CONSTANT_UnresolvedClass) { 905 return false; // wrong entry type; not our special case 906 } 907 908 jbyte t2 = cp2->tag_at(index2).value(); 909 if (t2 != JVM_CONSTANT_Class && t2 != JVM_CONSTANT_UnresolvedClass) { 910 return false; // wrong entry type; not our special case 911 } 912 913 if (t1 == t2) { 914 return false; // not a mismatch; not our special case 915 } 916 917 char *s1 = cp1->klass_name_at(index1)->as_C_string(); 918 char *s2 = cp2->klass_name_at(index2)->as_C_string(); 919 if (strcmp(s1, s2) != 0) { 920 return false; // strings don't match; not our special case 921 } 922 923 return true; // made it through the gauntlet; this is our special case 924 } // end is_unresolved_class_mismatch() 925 926 927 jvmtiError VM_RedefineClasses::load_new_class_versions(TRAPS) { 928 929 // For consistency allocate memory using os::malloc wrapper. 930 _scratch_classes = (Klass**) 931 os::malloc(sizeof(Klass*) * _class_count, mtClass); 932 if (_scratch_classes == NULL) { 933 return JVMTI_ERROR_OUT_OF_MEMORY; 934 } 935 // Zero initialize the _scratch_classes array. 936 for (int i = 0; i < _class_count; i++) { 937 _scratch_classes[i] = NULL; 938 } 939 940 ResourceMark rm(THREAD); 941 942 JvmtiThreadState *state = JvmtiThreadState::state_for(JavaThread::current()); 943 // state can only be NULL if the current thread is exiting which 944 // should not happen since we're trying to do a RedefineClasses 945 guarantee(state != NULL, "exiting thread calling load_new_class_versions"); 946 for (int i = 0; i < _class_count; i++) { 947 // Create HandleMark so that any handles created while loading new class 948 // versions are deleted. Constant pools are deallocated while merging 949 // constant pools 950 HandleMark hm(THREAD); 951 952 oop mirror = JNIHandles::resolve_non_null(_class_defs[i].klass); 953 // classes for primitives cannot be redefined 954 if (!is_modifiable_class(mirror)) { 955 return JVMTI_ERROR_UNMODIFIABLE_CLASS; 956 } 957 Klass* the_class_oop = java_lang_Class::as_Klass(mirror); 958 instanceKlassHandle the_class = instanceKlassHandle(THREAD, the_class_oop); 959 Symbol* the_class_sym = the_class->name(); 960 961 // RC_TRACE_WITH_THREAD macro has an embedded ResourceMark 962 RC_TRACE_WITH_THREAD(0x00000001, THREAD, 963 ("loading name=%s kind=%d (avail_mem=" UINT64_FORMAT "K)", 964 the_class->external_name(), _class_load_kind, 965 os::available_memory() >> 10)); 966 967 ClassFileStream st((u1*) _class_defs[i].class_bytes, 968 _class_defs[i].class_byte_count, (char *)"__VM_RedefineClasses__"); 969 970 // Parse the stream. 971 Handle the_class_loader(THREAD, the_class->class_loader()); 972 Handle protection_domain(THREAD, the_class->protection_domain()); 973 // Set redefined class handle in JvmtiThreadState class. 974 // This redefined class is sent to agent event handler for class file 975 // load hook event. 976 state->set_class_being_redefined(&the_class, _class_load_kind); 977 978 Klass* k = SystemDictionary::parse_stream(the_class_sym, 979 the_class_loader, 980 protection_domain, 981 &st, 982 THREAD); 983 // Clear class_being_redefined just to be sure. 984 state->clear_class_being_redefined(); 985 986 // TODO: if this is retransform, and nothing changed we can skip it 987 988 instanceKlassHandle scratch_class (THREAD, k); 989 990 // Need to clean up allocated InstanceKlass if there's an error so assign 991 // the result here. Caller deallocates all the scratch classes in case of 992 // an error. 993 _scratch_classes[i] = k; 994 995 if (HAS_PENDING_EXCEPTION) { 996 Symbol* ex_name = PENDING_EXCEPTION->klass()->name(); 997 // RC_TRACE_WITH_THREAD macro has an embedded ResourceMark 998 RC_TRACE_WITH_THREAD(0x00000002, THREAD, ("parse_stream exception: '%s'", 999 ex_name->as_C_string())); 1000 CLEAR_PENDING_EXCEPTION; 1001 1002 if (ex_name == vmSymbols::java_lang_UnsupportedClassVersionError()) { 1003 return JVMTI_ERROR_UNSUPPORTED_VERSION; 1004 } else if (ex_name == vmSymbols::java_lang_ClassFormatError()) { 1005 return JVMTI_ERROR_INVALID_CLASS_FORMAT; 1006 } else if (ex_name == vmSymbols::java_lang_ClassCircularityError()) { 1007 return JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION; 1008 } else if (ex_name == vmSymbols::java_lang_NoClassDefFoundError()) { 1009 // The message will be "XXX (wrong name: YYY)" 1010 return JVMTI_ERROR_NAMES_DONT_MATCH; 1011 } else if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) { 1012 return JVMTI_ERROR_OUT_OF_MEMORY; 1013 } else { // Just in case more exceptions can be thrown.. 1014 return JVMTI_ERROR_FAILS_VERIFICATION; 1015 } 1016 } 1017 1018 // Ensure class is linked before redefine 1019 if (!the_class->is_linked()) { 1020 the_class->link_class(THREAD); 1021 if (HAS_PENDING_EXCEPTION) { 1022 Symbol* ex_name = PENDING_EXCEPTION->klass()->name(); 1023 // RC_TRACE_WITH_THREAD macro has an embedded ResourceMark 1024 RC_TRACE_WITH_THREAD(0x00000002, THREAD, ("link_class exception: '%s'", 1025 ex_name->as_C_string())); 1026 CLEAR_PENDING_EXCEPTION; 1027 if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) { 1028 return JVMTI_ERROR_OUT_OF_MEMORY; 1029 } else { 1030 return JVMTI_ERROR_INTERNAL; 1031 } 1032 } 1033 } 1034 1035 // Do the validity checks in compare_and_normalize_class_versions() 1036 // before verifying the byte codes. By doing these checks first, we 1037 // limit the number of functions that require redirection from 1038 // the_class to scratch_class. In particular, we don't have to 1039 // modify JNI GetSuperclass() and thus won't change its performance. 1040 jvmtiError res = compare_and_normalize_class_versions(the_class, 1041 scratch_class); 1042 if (res != JVMTI_ERROR_NONE) { 1043 return res; 1044 } 1045 1046 // verify what the caller passed us 1047 { 1048 // The bug 6214132 caused the verification to fail. 1049 // Information about the_class and scratch_class is temporarily 1050 // recorded into jvmtiThreadState. This data is used to redirect 1051 // the_class to scratch_class in the JVM_* functions called by the 1052 // verifier. Please, refer to jvmtiThreadState.hpp for the detailed 1053 // description. 1054 RedefineVerifyMark rvm(&the_class, &scratch_class, state); 1055 Verifier::verify( 1056 scratch_class, Verifier::ThrowException, true, THREAD); 1057 } 1058 1059 if (HAS_PENDING_EXCEPTION) { 1060 Symbol* ex_name = PENDING_EXCEPTION->klass()->name(); 1061 // RC_TRACE_WITH_THREAD macro has an embedded ResourceMark 1062 RC_TRACE_WITH_THREAD(0x00000002, THREAD, 1063 ("verify_byte_codes exception: '%s'", ex_name->as_C_string())); 1064 CLEAR_PENDING_EXCEPTION; 1065 if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) { 1066 return JVMTI_ERROR_OUT_OF_MEMORY; 1067 } else { 1068 // tell the caller the bytecodes are bad 1069 return JVMTI_ERROR_FAILS_VERIFICATION; 1070 } 1071 } 1072 1073 res = merge_cp_and_rewrite(the_class, scratch_class, THREAD); 1074 if (res != JVMTI_ERROR_NONE) { 1075 return res; 1076 } 1077 1078 if (VerifyMergedCPBytecodes) { 1079 // verify what we have done during constant pool merging 1080 { 1081 RedefineVerifyMark rvm(&the_class, &scratch_class, state); 1082 Verifier::verify(scratch_class, Verifier::ThrowException, true, THREAD); 1083 } 1084 1085 if (HAS_PENDING_EXCEPTION) { 1086 Symbol* ex_name = PENDING_EXCEPTION->klass()->name(); 1087 // RC_TRACE_WITH_THREAD macro has an embedded ResourceMark 1088 RC_TRACE_WITH_THREAD(0x00000002, THREAD, 1089 ("verify_byte_codes post merge-CP exception: '%s'", 1090 ex_name->as_C_string())); 1091 CLEAR_PENDING_EXCEPTION; 1092 if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) { 1093 return JVMTI_ERROR_OUT_OF_MEMORY; 1094 } else { 1095 // tell the caller that constant pool merging screwed up 1096 return JVMTI_ERROR_INTERNAL; 1097 } 1098 } 1099 } 1100 1101 Rewriter::rewrite(scratch_class, THREAD); 1102 if (!HAS_PENDING_EXCEPTION) { 1103 scratch_class->link_methods(THREAD); 1104 } 1105 if (HAS_PENDING_EXCEPTION) { 1106 Symbol* ex_name = PENDING_EXCEPTION->klass()->name(); 1107 CLEAR_PENDING_EXCEPTION; 1108 if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) { 1109 return JVMTI_ERROR_OUT_OF_MEMORY; 1110 } else { 1111 return JVMTI_ERROR_INTERNAL; 1112 } 1113 } 1114 1115 // RC_TRACE_WITH_THREAD macro has an embedded ResourceMark 1116 RC_TRACE_WITH_THREAD(0x00000001, THREAD, 1117 ("loaded name=%s (avail_mem=" UINT64_FORMAT "K)", 1118 the_class->external_name(), os::available_memory() >> 10)); 1119 } 1120 1121 return JVMTI_ERROR_NONE; 1122 } 1123 1124 1125 // Map old_index to new_index as needed. scratch_cp is only needed 1126 // for RC_TRACE() calls. 1127 void VM_RedefineClasses::map_index(constantPoolHandle scratch_cp, 1128 int old_index, int new_index) { 1129 if (find_new_index(old_index) != 0) { 1130 // old_index is already mapped 1131 return; 1132 } 1133 1134 if (old_index == new_index) { 1135 // no mapping is needed 1136 return; 1137 } 1138 1139 _index_map_p->at_put(old_index, new_index); 1140 _index_map_count++; 1141 1142 RC_TRACE(0x00040000, ("mapped tag %d at index %d to %d", 1143 scratch_cp->tag_at(old_index).value(), old_index, new_index)); 1144 } // end map_index() 1145 1146 1147 // Map old_index to new_index as needed. 1148 void VM_RedefineClasses::map_operand_index(int old_index, int new_index) { 1149 if (find_new_operand_index(old_index) != -1) { 1150 // old_index is already mapped 1151 return; 1152 } 1153 1154 if (old_index == new_index) { 1155 // no mapping is needed 1156 return; 1157 } 1158 1159 _operands_index_map_p->at_put(old_index, new_index); 1160 _operands_index_map_count++; 1161 1162 RC_TRACE(0x00040000, ("mapped bootstrap specifier at index %d to %d", old_index, new_index)); 1163 } // end map_index() 1164 1165 1166 // Merge old_cp and scratch_cp and return the results of the merge via 1167 // merge_cp_p. The number of entries in *merge_cp_p is returned via 1168 // merge_cp_length_p. The entries in old_cp occupy the same locations 1169 // in *merge_cp_p. Also creates a map of indices from entries in 1170 // scratch_cp to the corresponding entry in *merge_cp_p. Index map 1171 // entries are only created for entries in scratch_cp that occupy a 1172 // different location in *merged_cp_p. 1173 bool VM_RedefineClasses::merge_constant_pools(constantPoolHandle old_cp, 1174 constantPoolHandle scratch_cp, constantPoolHandle *merge_cp_p, 1175 int *merge_cp_length_p, TRAPS) { 1176 1177 if (merge_cp_p == NULL) { 1178 assert(false, "caller must provide scratch constantPool"); 1179 return false; // robustness 1180 } 1181 if (merge_cp_length_p == NULL) { 1182 assert(false, "caller must provide scratch CP length"); 1183 return false; // robustness 1184 } 1185 // Worst case we need old_cp->length() + scratch_cp()->length(), 1186 // but the caller might be smart so make sure we have at least 1187 // the minimum. 1188 if ((*merge_cp_p)->length() < old_cp->length()) { 1189 assert(false, "merge area too small"); 1190 return false; // robustness 1191 } 1192 1193 RC_TRACE_WITH_THREAD(0x00010000, THREAD, 1194 ("old_cp_len=%d, scratch_cp_len=%d", old_cp->length(), 1195 scratch_cp->length())); 1196 1197 { 1198 // Pass 0: 1199 // The old_cp is copied to *merge_cp_p; this means that any code 1200 // using old_cp does not have to change. This work looks like a 1201 // perfect fit for ConstantPool*::copy_cp_to(), but we need to 1202 // handle one special case: 1203 // - revert JVM_CONSTANT_Class to JVM_CONSTANT_UnresolvedClass 1204 // This will make verification happy. 1205 1206 int old_i; // index into old_cp 1207 1208 // index zero (0) is not used in constantPools 1209 for (old_i = 1; old_i < old_cp->length(); old_i++) { 1210 // leave debugging crumb 1211 jbyte old_tag = old_cp->tag_at(old_i).value(); 1212 switch (old_tag) { 1213 case JVM_CONSTANT_Class: 1214 case JVM_CONSTANT_UnresolvedClass: 1215 // revert the copy to JVM_CONSTANT_UnresolvedClass 1216 // May be resolving while calling this so do the same for 1217 // JVM_CONSTANT_UnresolvedClass (klass_name_at() deals with transition) 1218 (*merge_cp_p)->unresolved_klass_at_put(old_i, 1219 old_cp->klass_name_at(old_i)); 1220 break; 1221 1222 case JVM_CONSTANT_Double: 1223 case JVM_CONSTANT_Long: 1224 // just copy the entry to *merge_cp_p, but double and long take 1225 // two constant pool entries 1226 ConstantPool::copy_entry_to(old_cp, old_i, *merge_cp_p, old_i, CHECK_0); 1227 old_i++; 1228 break; 1229 1230 default: 1231 // just copy the entry to *merge_cp_p 1232 ConstantPool::copy_entry_to(old_cp, old_i, *merge_cp_p, old_i, CHECK_0); 1233 break; 1234 } 1235 } // end for each old_cp entry 1236 1237 ConstantPool::copy_operands(old_cp, *merge_cp_p, CHECK_0); 1238 (*merge_cp_p)->extend_operands(scratch_cp, CHECK_0); 1239 1240 // We don't need to sanity check that *merge_cp_length_p is within 1241 // *merge_cp_p bounds since we have the minimum on-entry check above. 1242 (*merge_cp_length_p) = old_i; 1243 } 1244 1245 // merge_cp_len should be the same as old_cp->length() at this point 1246 // so this trace message is really a "warm-and-breathing" message. 1247 RC_TRACE_WITH_THREAD(0x00020000, THREAD, 1248 ("after pass 0: merge_cp_len=%d", *merge_cp_length_p)); 1249 1250 int scratch_i; // index into scratch_cp 1251 { 1252 // Pass 1a: 1253 // Compare scratch_cp entries to the old_cp entries that we have 1254 // already copied to *merge_cp_p. In this pass, we are eliminating 1255 // exact duplicates (matching entry at same index) so we only 1256 // compare entries in the common indice range. 1257 int increment = 1; 1258 int pass1a_length = MIN2(old_cp->length(), scratch_cp->length()); 1259 for (scratch_i = 1; scratch_i < pass1a_length; scratch_i += increment) { 1260 switch (scratch_cp->tag_at(scratch_i).value()) { 1261 case JVM_CONSTANT_Double: 1262 case JVM_CONSTANT_Long: 1263 // double and long take two constant pool entries 1264 increment = 2; 1265 break; 1266 1267 default: 1268 increment = 1; 1269 break; 1270 } 1271 1272 bool match = scratch_cp->compare_entry_to(scratch_i, *merge_cp_p, 1273 scratch_i, CHECK_0); 1274 if (match) { 1275 // found a match at the same index so nothing more to do 1276 continue; 1277 } else if (is_unresolved_class_mismatch(scratch_cp, scratch_i, 1278 *merge_cp_p, scratch_i)) { 1279 // The mismatch in compare_entry_to() above is because of a 1280 // resolved versus unresolved class entry at the same index 1281 // with the same string value. Since Pass 0 reverted any 1282 // class entries to unresolved class entries in *merge_cp_p, 1283 // we go with the unresolved class entry. 1284 continue; 1285 } 1286 1287 int found_i = scratch_cp->find_matching_entry(scratch_i, *merge_cp_p, 1288 CHECK_0); 1289 if (found_i != 0) { 1290 guarantee(found_i != scratch_i, 1291 "compare_entry_to() and find_matching_entry() do not agree"); 1292 1293 // Found a matching entry somewhere else in *merge_cp_p so 1294 // just need a mapping entry. 1295 map_index(scratch_cp, scratch_i, found_i); 1296 continue; 1297 } 1298 1299 // The find_matching_entry() call above could fail to find a match 1300 // due to a resolved versus unresolved class or string entry situation 1301 // like we solved above with the is_unresolved_*_mismatch() calls. 1302 // However, we would have to call is_unresolved_*_mismatch() over 1303 // all of *merge_cp_p (potentially) and that doesn't seem to be 1304 // worth the time. 1305 1306 // No match found so we have to append this entry and any unique 1307 // referenced entries to *merge_cp_p. 1308 append_entry(scratch_cp, scratch_i, merge_cp_p, merge_cp_length_p, 1309 CHECK_0); 1310 } 1311 } 1312 1313 RC_TRACE_WITH_THREAD(0x00020000, THREAD, 1314 ("after pass 1a: merge_cp_len=%d, scratch_i=%d, index_map_len=%d", 1315 *merge_cp_length_p, scratch_i, _index_map_count)); 1316 1317 if (scratch_i < scratch_cp->length()) { 1318 // Pass 1b: 1319 // old_cp is smaller than scratch_cp so there are entries in 1320 // scratch_cp that we have not yet processed. We take care of 1321 // those now. 1322 int increment = 1; 1323 for (; scratch_i < scratch_cp->length(); scratch_i += increment) { 1324 switch (scratch_cp->tag_at(scratch_i).value()) { 1325 case JVM_CONSTANT_Double: 1326 case JVM_CONSTANT_Long: 1327 // double and long take two constant pool entries 1328 increment = 2; 1329 break; 1330 1331 default: 1332 increment = 1; 1333 break; 1334 } 1335 1336 int found_i = 1337 scratch_cp->find_matching_entry(scratch_i, *merge_cp_p, CHECK_0); 1338 if (found_i != 0) { 1339 // Found a matching entry somewhere else in *merge_cp_p so 1340 // just need a mapping entry. 1341 map_index(scratch_cp, scratch_i, found_i); 1342 continue; 1343 } 1344 1345 // No match found so we have to append this entry and any unique 1346 // referenced entries to *merge_cp_p. 1347 append_entry(scratch_cp, scratch_i, merge_cp_p, merge_cp_length_p, 1348 CHECK_0); 1349 } 1350 1351 finalize_operands_merge(*merge_cp_p, THREAD); 1352 1353 RC_TRACE_WITH_THREAD(0x00020000, THREAD, 1354 ("after pass 1b: merge_cp_len=%d, scratch_i=%d, index_map_len=%d", 1355 *merge_cp_length_p, scratch_i, _index_map_count)); 1356 } 1357 1358 return true; 1359 } // end merge_constant_pools() 1360 1361 1362 // Scoped object to clean up the constant pool(s) created for merging 1363 class MergeCPCleaner { 1364 ClassLoaderData* _loader_data; 1365 ConstantPool* _cp; 1366 ConstantPool* _scratch_cp; 1367 public: 1368 MergeCPCleaner(ClassLoaderData* loader_data, ConstantPool* merge_cp) : 1369 _loader_data(loader_data), _cp(merge_cp), _scratch_cp(NULL) {} 1370 ~MergeCPCleaner() { 1371 _loader_data->add_to_deallocate_list(_cp); 1372 if (_scratch_cp != NULL) { 1373 _loader_data->add_to_deallocate_list(_scratch_cp); 1374 } 1375 } 1376 void add_scratch_cp(ConstantPool* scratch_cp) { _scratch_cp = scratch_cp; } 1377 }; 1378 1379 // Merge constant pools between the_class and scratch_class and 1380 // potentially rewrite bytecodes in scratch_class to use the merged 1381 // constant pool. 1382 jvmtiError VM_RedefineClasses::merge_cp_and_rewrite( 1383 instanceKlassHandle the_class, instanceKlassHandle scratch_class, 1384 TRAPS) { 1385 // worst case merged constant pool length is old and new combined 1386 int merge_cp_length = the_class->constants()->length() 1387 + scratch_class->constants()->length(); 1388 1389 // Constant pools are not easily reused so we allocate a new one 1390 // each time. 1391 // merge_cp is created unsafe for concurrent GC processing. It 1392 // should be marked safe before discarding it. Even though 1393 // garbage, if it crosses a card boundary, it may be scanned 1394 // in order to find the start of the first complete object on the card. 1395 ClassLoaderData* loader_data = the_class->class_loader_data(); 1396 ConstantPool* merge_cp_oop = 1397 ConstantPool::allocate(loader_data, 1398 merge_cp_length, 1399 THREAD); 1400 MergeCPCleaner cp_cleaner(loader_data, merge_cp_oop); 1401 1402 HandleMark hm(THREAD); // make sure handles are cleared before 1403 // MergeCPCleaner clears out merge_cp_oop 1404 constantPoolHandle merge_cp(THREAD, merge_cp_oop); 1405 1406 // Get constants() from the old class because it could have been rewritten 1407 // while we were at a safepoint allocating a new constant pool. 1408 constantPoolHandle old_cp(THREAD, the_class->constants()); 1409 constantPoolHandle scratch_cp(THREAD, scratch_class->constants()); 1410 1411 // If the length changed, the class was redefined out from under us. Return 1412 // an error. 1413 if (merge_cp_length != the_class->constants()->length() 1414 + scratch_class->constants()->length()) { 1415 return JVMTI_ERROR_INTERNAL; 1416 } 1417 1418 // Update the version number of the constant pool 1419 merge_cp->increment_and_save_version(old_cp->version()); 1420 1421 ResourceMark rm(THREAD); 1422 _index_map_count = 0; 1423 _index_map_p = new intArray(scratch_cp->length(), -1); 1424 1425 _operands_cur_length = ConstantPool::operand_array_length(old_cp->operands()); 1426 _operands_index_map_count = 0; 1427 _operands_index_map_p = new intArray( 1428 ConstantPool::operand_array_length(scratch_cp->operands()), -1); 1429 1430 // reference to the cp holder is needed for copy_operands() 1431 merge_cp->set_pool_holder(scratch_class()); 1432 bool result = merge_constant_pools(old_cp, scratch_cp, &merge_cp, 1433 &merge_cp_length, THREAD); 1434 merge_cp->set_pool_holder(NULL); 1435 1436 if (!result) { 1437 // The merge can fail due to memory allocation failure or due 1438 // to robustness checks. 1439 return JVMTI_ERROR_INTERNAL; 1440 } 1441 1442 RC_TRACE_WITH_THREAD(0x00010000, THREAD, 1443 ("merge_cp_len=%d, index_map_len=%d", merge_cp_length, _index_map_count)); 1444 1445 if (_index_map_count == 0) { 1446 // there is nothing to map between the new and merged constant pools 1447 1448 if (old_cp->length() == scratch_cp->length()) { 1449 // The old and new constant pools are the same length and the 1450 // index map is empty. This means that the three constant pools 1451 // are equivalent (but not the same). Unfortunately, the new 1452 // constant pool has not gone through link resolution nor have 1453 // the new class bytecodes gone through constant pool cache 1454 // rewriting so we can't use the old constant pool with the new 1455 // class. 1456 1457 // toss the merged constant pool at return 1458 } else if (old_cp->length() < scratch_cp->length()) { 1459 // The old constant pool has fewer entries than the new constant 1460 // pool and the index map is empty. This means the new constant 1461 // pool is a superset of the old constant pool. However, the old 1462 // class bytecodes have already gone through constant pool cache 1463 // rewriting so we can't use the new constant pool with the old 1464 // class. 1465 1466 // toss the merged constant pool at return 1467 } else { 1468 // The old constant pool has more entries than the new constant 1469 // pool and the index map is empty. This means that both the old 1470 // and merged constant pools are supersets of the new constant 1471 // pool. 1472 1473 // Replace the new constant pool with a shrunken copy of the 1474 // merged constant pool 1475 set_new_constant_pool(loader_data, scratch_class, merge_cp, merge_cp_length, THREAD); 1476 // The new constant pool replaces scratch_cp so have cleaner clean it up. 1477 // It can't be cleaned up while there are handles to it. 1478 cp_cleaner.add_scratch_cp(scratch_cp()); 1479 } 1480 } else { 1481 if (RC_TRACE_ENABLED(0x00040000)) { 1482 // don't want to loop unless we are tracing 1483 int count = 0; 1484 for (int i = 1; i < _index_map_p->length(); i++) { 1485 int value = _index_map_p->at(i); 1486 1487 if (value != -1) { 1488 RC_TRACE_WITH_THREAD(0x00040000, THREAD, 1489 ("index_map[%d]: old=%d new=%d", count, i, value)); 1490 count++; 1491 } 1492 } 1493 } 1494 1495 // We have entries mapped between the new and merged constant pools 1496 // so we have to rewrite some constant pool references. 1497 if (!rewrite_cp_refs(scratch_class, THREAD)) { 1498 return JVMTI_ERROR_INTERNAL; 1499 } 1500 1501 // Replace the new constant pool with a shrunken copy of the 1502 // merged constant pool so now the rewritten bytecodes have 1503 // valid references; the previous new constant pool will get 1504 // GCed. 1505 set_new_constant_pool(loader_data, scratch_class, merge_cp, merge_cp_length, THREAD); 1506 // The new constant pool replaces scratch_cp so have cleaner clean it up. 1507 // It can't be cleaned up while there are handles to it. 1508 cp_cleaner.add_scratch_cp(scratch_cp()); 1509 } 1510 1511 return JVMTI_ERROR_NONE; 1512 } // end merge_cp_and_rewrite() 1513 1514 1515 // Rewrite constant pool references in klass scratch_class. 1516 bool VM_RedefineClasses::rewrite_cp_refs(instanceKlassHandle scratch_class, 1517 TRAPS) { 1518 1519 // rewrite constant pool references in the methods: 1520 if (!rewrite_cp_refs_in_methods(scratch_class, THREAD)) { 1521 // propagate failure back to caller 1522 return false; 1523 } 1524 1525 // rewrite constant pool references in the class_annotations: 1526 if (!rewrite_cp_refs_in_class_annotations(scratch_class, THREAD)) { 1527 // propagate failure back to caller 1528 return false; 1529 } 1530 1531 // rewrite constant pool references in the fields_annotations: 1532 if (!rewrite_cp_refs_in_fields_annotations(scratch_class, THREAD)) { 1533 // propagate failure back to caller 1534 return false; 1535 } 1536 1537 // rewrite constant pool references in the methods_annotations: 1538 if (!rewrite_cp_refs_in_methods_annotations(scratch_class, THREAD)) { 1539 // propagate failure back to caller 1540 return false; 1541 } 1542 1543 // rewrite constant pool references in the methods_parameter_annotations: 1544 if (!rewrite_cp_refs_in_methods_parameter_annotations(scratch_class, 1545 THREAD)) { 1546 // propagate failure back to caller 1547 return false; 1548 } 1549 1550 // rewrite constant pool references in the methods_default_annotations: 1551 if (!rewrite_cp_refs_in_methods_default_annotations(scratch_class, 1552 THREAD)) { 1553 // propagate failure back to caller 1554 return false; 1555 } 1556 1557 return true; 1558 } // end rewrite_cp_refs() 1559 1560 // Rewrite constant pool references in the methods. 1561 bool VM_RedefineClasses::rewrite_cp_refs_in_methods( 1562 instanceKlassHandle scratch_class, TRAPS) { 1563 1564 Array<Method*>* methods = scratch_class->methods(); 1565 1566 if (methods == NULL || methods->length() == 0) { 1567 // no methods so nothing to do 1568 return true; 1569 } 1570 1571 // rewrite constant pool references in the methods: 1572 for (int i = methods->length() - 1; i >= 0; i--) { 1573 methodHandle method(THREAD, methods->at(i)); 1574 methodHandle new_method; 1575 rewrite_cp_refs_in_method(method, &new_method, CHECK_false); 1576 if (!new_method.is_null()) { 1577 // the method has been replaced so save the new method version 1578 methods->at_put(i, new_method()); 1579 } 1580 } 1581 1582 return true; 1583 } 1584 1585 1586 // Rewrite constant pool references in the specific method. This code 1587 // was adapted from Rewriter::rewrite_method(). 1588 void VM_RedefineClasses::rewrite_cp_refs_in_method(methodHandle method, 1589 methodHandle *new_method_p, TRAPS) { 1590 1591 *new_method_p = methodHandle(); // default is no new method 1592 1593 // We cache a pointer to the bytecodes here in code_base. If GC 1594 // moves the Method*, then the bytecodes will also move which 1595 // will likely cause a crash. We create a No_Safepoint_Verifier 1596 // object to detect whether we pass a possible safepoint in this 1597 // code block. 1598 No_Safepoint_Verifier nsv; 1599 1600 // Bytecodes and their length 1601 address code_base = method->code_base(); 1602 int code_length = method->code_size(); 1603 1604 int bc_length; 1605 for (int bci = 0; bci < code_length; bci += bc_length) { 1606 address bcp = code_base + bci; 1607 Bytecodes::Code c = (Bytecodes::Code)(*bcp); 1608 1609 bc_length = Bytecodes::length_for(c); 1610 if (bc_length == 0) { 1611 // More complicated bytecodes report a length of zero so 1612 // we have to try again a slightly different way. 1613 bc_length = Bytecodes::length_at(method(), bcp); 1614 } 1615 1616 assert(bc_length != 0, "impossible bytecode length"); 1617 1618 switch (c) { 1619 case Bytecodes::_ldc: 1620 { 1621 int cp_index = *(bcp + 1); 1622 int new_index = find_new_index(cp_index); 1623 1624 if (StressLdcRewrite && new_index == 0) { 1625 // If we are stressing ldc -> ldc_w rewriting, then we 1626 // always need a new_index value. 1627 new_index = cp_index; 1628 } 1629 if (new_index != 0) { 1630 // the original index is mapped so we have more work to do 1631 if (!StressLdcRewrite && new_index <= max_jubyte) { 1632 // The new value can still use ldc instead of ldc_w 1633 // unless we are trying to stress ldc -> ldc_w rewriting 1634 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 1635 ("%s@" INTPTR_FORMAT " old=%d, new=%d", Bytecodes::name(c), 1636 bcp, cp_index, new_index)); 1637 *(bcp + 1) = new_index; 1638 } else { 1639 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 1640 ("%s->ldc_w@" INTPTR_FORMAT " old=%d, new=%d", 1641 Bytecodes::name(c), bcp, cp_index, new_index)); 1642 // the new value needs ldc_w instead of ldc 1643 u_char inst_buffer[4]; // max instruction size is 4 bytes 1644 bcp = (address)inst_buffer; 1645 // construct new instruction sequence 1646 *bcp = Bytecodes::_ldc_w; 1647 bcp++; 1648 // Rewriter::rewrite_method() does not rewrite ldc -> ldc_w. 1649 // See comment below for difference between put_Java_u2() 1650 // and put_native_u2(). 1651 Bytes::put_Java_u2(bcp, new_index); 1652 1653 Relocator rc(method, NULL /* no RelocatorListener needed */); 1654 methodHandle m; 1655 { 1656 Pause_No_Safepoint_Verifier pnsv(&nsv); 1657 1658 // ldc is 2 bytes and ldc_w is 3 bytes 1659 m = rc.insert_space_at(bci, 3, inst_buffer, THREAD); 1660 if (m.is_null() || HAS_PENDING_EXCEPTION) { 1661 guarantee(false, "insert_space_at() failed"); 1662 } 1663 } 1664 1665 // return the new method so that the caller can update 1666 // the containing class 1667 *new_method_p = method = m; 1668 // switch our bytecode processing loop from the old method 1669 // to the new method 1670 code_base = method->code_base(); 1671 code_length = method->code_size(); 1672 bcp = code_base + bci; 1673 c = (Bytecodes::Code)(*bcp); 1674 bc_length = Bytecodes::length_for(c); 1675 assert(bc_length != 0, "sanity check"); 1676 } // end we need ldc_w instead of ldc 1677 } // end if there is a mapped index 1678 } break; 1679 1680 // these bytecodes have a two-byte constant pool index 1681 case Bytecodes::_anewarray : // fall through 1682 case Bytecodes::_checkcast : // fall through 1683 case Bytecodes::_getfield : // fall through 1684 case Bytecodes::_getstatic : // fall through 1685 case Bytecodes::_instanceof : // fall through 1686 case Bytecodes::_invokedynamic : // fall through 1687 case Bytecodes::_invokeinterface: // fall through 1688 case Bytecodes::_invokespecial : // fall through 1689 case Bytecodes::_invokestatic : // fall through 1690 case Bytecodes::_invokevirtual : // fall through 1691 case Bytecodes::_ldc_w : // fall through 1692 case Bytecodes::_ldc2_w : // fall through 1693 case Bytecodes::_multianewarray : // fall through 1694 case Bytecodes::_new : // fall through 1695 case Bytecodes::_putfield : // fall through 1696 case Bytecodes::_putstatic : 1697 { 1698 address p = bcp + 1; 1699 int cp_index = Bytes::get_Java_u2(p); 1700 int new_index = find_new_index(cp_index); 1701 if (new_index != 0) { 1702 // the original index is mapped so update w/ new value 1703 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 1704 ("%s@" INTPTR_FORMAT " old=%d, new=%d", Bytecodes::name(c), 1705 bcp, cp_index, new_index)); 1706 // Rewriter::rewrite_method() uses put_native_u2() in this 1707 // situation because it is reusing the constant pool index 1708 // location for a native index into the ConstantPoolCache. 1709 // Since we are updating the constant pool index prior to 1710 // verification and ConstantPoolCache initialization, we 1711 // need to keep the new index in Java byte order. 1712 Bytes::put_Java_u2(p, new_index); 1713 } 1714 } break; 1715 } 1716 } // end for each bytecode 1717 1718 // We also need to rewrite the parameter name indexes, if there is 1719 // method parameter data present 1720 if(method->has_method_parameters()) { 1721 const int len = method->method_parameters_length(); 1722 MethodParametersElement* elem = method->method_parameters_start(); 1723 1724 for (int i = 0; i < len; i++) { 1725 const u2 cp_index = elem[i].name_cp_index; 1726 elem[i].name_cp_index = find_new_index(cp_index); 1727 } 1728 } 1729 } // end rewrite_cp_refs_in_method() 1730 1731 1732 // Rewrite constant pool references in the class_annotations field. 1733 bool VM_RedefineClasses::rewrite_cp_refs_in_class_annotations( 1734 instanceKlassHandle scratch_class, TRAPS) { 1735 1736 AnnotationArray* class_annotations = scratch_class->class_annotations(); 1737 if (class_annotations == NULL || class_annotations->length() == 0) { 1738 // no class_annotations so nothing to do 1739 return true; 1740 } 1741 1742 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1743 ("class_annotations length=%d", class_annotations->length())); 1744 1745 int byte_i = 0; // byte index into class_annotations 1746 return rewrite_cp_refs_in_annotations_typeArray(class_annotations, byte_i, 1747 THREAD); 1748 } 1749 1750 1751 // Rewrite constant pool references in an annotations typeArray. This 1752 // "structure" is adapted from the RuntimeVisibleAnnotations_attribute 1753 // that is described in section 4.8.15 of the 2nd-edition of the VM spec: 1754 // 1755 // annotations_typeArray { 1756 // u2 num_annotations; 1757 // annotation annotations[num_annotations]; 1758 // } 1759 // 1760 bool VM_RedefineClasses::rewrite_cp_refs_in_annotations_typeArray( 1761 AnnotationArray* annotations_typeArray, int &byte_i_ref, TRAPS) { 1762 1763 if ((byte_i_ref + 2) > annotations_typeArray->length()) { 1764 // not enough room for num_annotations field 1765 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1766 ("length() is too small for num_annotations field")); 1767 return false; 1768 } 1769 1770 u2 num_annotations = Bytes::get_Java_u2((address) 1771 annotations_typeArray->adr_at(byte_i_ref)); 1772 byte_i_ref += 2; 1773 1774 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1775 ("num_annotations=%d", num_annotations)); 1776 1777 int calc_num_annotations = 0; 1778 for (; calc_num_annotations < num_annotations; calc_num_annotations++) { 1779 if (!rewrite_cp_refs_in_annotation_struct(annotations_typeArray, 1780 byte_i_ref, THREAD)) { 1781 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1782 ("bad annotation_struct at %d", calc_num_annotations)); 1783 // propagate failure back to caller 1784 return false; 1785 } 1786 } 1787 assert(num_annotations == calc_num_annotations, "sanity check"); 1788 1789 return true; 1790 } // end rewrite_cp_refs_in_annotations_typeArray() 1791 1792 1793 // Rewrite constant pool references in the annotation struct portion of 1794 // an annotations_typeArray. This "structure" is from section 4.8.15 of 1795 // the 2nd-edition of the VM spec: 1796 // 1797 // struct annotation { 1798 // u2 type_index; 1799 // u2 num_element_value_pairs; 1800 // { 1801 // u2 element_name_index; 1802 // element_value value; 1803 // } element_value_pairs[num_element_value_pairs]; 1804 // } 1805 // 1806 bool VM_RedefineClasses::rewrite_cp_refs_in_annotation_struct( 1807 AnnotationArray* annotations_typeArray, int &byte_i_ref, TRAPS) { 1808 if ((byte_i_ref + 2 + 2) > annotations_typeArray->length()) { 1809 // not enough room for smallest annotation_struct 1810 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1811 ("length() is too small for annotation_struct")); 1812 return false; 1813 } 1814 1815 u2 type_index = rewrite_cp_ref_in_annotation_data(annotations_typeArray, 1816 byte_i_ref, "mapped old type_index=%d", THREAD); 1817 1818 u2 num_element_value_pairs = Bytes::get_Java_u2((address) 1819 annotations_typeArray->adr_at(byte_i_ref)); 1820 byte_i_ref += 2; 1821 1822 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1823 ("type_index=%d num_element_value_pairs=%d", type_index, 1824 num_element_value_pairs)); 1825 1826 int calc_num_element_value_pairs = 0; 1827 for (; calc_num_element_value_pairs < num_element_value_pairs; 1828 calc_num_element_value_pairs++) { 1829 if ((byte_i_ref + 2) > annotations_typeArray->length()) { 1830 // not enough room for another element_name_index, let alone 1831 // the rest of another component 1832 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1833 ("length() is too small for element_name_index")); 1834 return false; 1835 } 1836 1837 u2 element_name_index = rewrite_cp_ref_in_annotation_data( 1838 annotations_typeArray, byte_i_ref, 1839 "mapped old element_name_index=%d", THREAD); 1840 1841 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1842 ("element_name_index=%d", element_name_index)); 1843 1844 if (!rewrite_cp_refs_in_element_value(annotations_typeArray, 1845 byte_i_ref, THREAD)) { 1846 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1847 ("bad element_value at %d", calc_num_element_value_pairs)); 1848 // propagate failure back to caller 1849 return false; 1850 } 1851 } // end for each component 1852 assert(num_element_value_pairs == calc_num_element_value_pairs, 1853 "sanity check"); 1854 1855 return true; 1856 } // end rewrite_cp_refs_in_annotation_struct() 1857 1858 1859 // Rewrite a constant pool reference at the current position in 1860 // annotations_typeArray if needed. Returns the original constant 1861 // pool reference if a rewrite was not needed or the new constant 1862 // pool reference if a rewrite was needed. 1863 u2 VM_RedefineClasses::rewrite_cp_ref_in_annotation_data( 1864 AnnotationArray* annotations_typeArray, int &byte_i_ref, 1865 const char * trace_mesg, TRAPS) { 1866 1867 address cp_index_addr = (address) 1868 annotations_typeArray->adr_at(byte_i_ref); 1869 u2 old_cp_index = Bytes::get_Java_u2(cp_index_addr); 1870 u2 new_cp_index = find_new_index(old_cp_index); 1871 if (new_cp_index != 0) { 1872 RC_TRACE_WITH_THREAD(0x02000000, THREAD, (trace_mesg, old_cp_index)); 1873 Bytes::put_Java_u2(cp_index_addr, new_cp_index); 1874 old_cp_index = new_cp_index; 1875 } 1876 byte_i_ref += 2; 1877 return old_cp_index; 1878 } 1879 1880 1881 // Rewrite constant pool references in the element_value portion of an 1882 // annotations_typeArray. This "structure" is from section 4.8.15.1 of 1883 // the 2nd-edition of the VM spec: 1884 // 1885 // struct element_value { 1886 // u1 tag; 1887 // union { 1888 // u2 const_value_index; 1889 // { 1890 // u2 type_name_index; 1891 // u2 const_name_index; 1892 // } enum_const_value; 1893 // u2 class_info_index; 1894 // annotation annotation_value; 1895 // struct { 1896 // u2 num_values; 1897 // element_value values[num_values]; 1898 // } array_value; 1899 // } value; 1900 // } 1901 // 1902 bool VM_RedefineClasses::rewrite_cp_refs_in_element_value( 1903 AnnotationArray* annotations_typeArray, int &byte_i_ref, TRAPS) { 1904 1905 if ((byte_i_ref + 1) > annotations_typeArray->length()) { 1906 // not enough room for a tag let alone the rest of an element_value 1907 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1908 ("length() is too small for a tag")); 1909 return false; 1910 } 1911 1912 u1 tag = annotations_typeArray->at(byte_i_ref); 1913 byte_i_ref++; 1914 RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("tag='%c'", tag)); 1915 1916 switch (tag) { 1917 // These BaseType tag values are from Table 4.2 in VM spec: 1918 case 'B': // byte 1919 case 'C': // char 1920 case 'D': // double 1921 case 'F': // float 1922 case 'I': // int 1923 case 'J': // long 1924 case 'S': // short 1925 case 'Z': // boolean 1926 1927 // The remaining tag values are from Table 4.8 in the 2nd-edition of 1928 // the VM spec: 1929 case 's': 1930 { 1931 // For the above tag values (including the BaseType values), 1932 // value.const_value_index is right union field. 1933 1934 if ((byte_i_ref + 2) > annotations_typeArray->length()) { 1935 // not enough room for a const_value_index 1936 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1937 ("length() is too small for a const_value_index")); 1938 return false; 1939 } 1940 1941 u2 const_value_index = rewrite_cp_ref_in_annotation_data( 1942 annotations_typeArray, byte_i_ref, 1943 "mapped old const_value_index=%d", THREAD); 1944 1945 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1946 ("const_value_index=%d", const_value_index)); 1947 } break; 1948 1949 case 'e': 1950 { 1951 // for the above tag value, value.enum_const_value is right union field 1952 1953 if ((byte_i_ref + 4) > annotations_typeArray->length()) { 1954 // not enough room for a enum_const_value 1955 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1956 ("length() is too small for a enum_const_value")); 1957 return false; 1958 } 1959 1960 u2 type_name_index = rewrite_cp_ref_in_annotation_data( 1961 annotations_typeArray, byte_i_ref, 1962 "mapped old type_name_index=%d", THREAD); 1963 1964 u2 const_name_index = rewrite_cp_ref_in_annotation_data( 1965 annotations_typeArray, byte_i_ref, 1966 "mapped old const_name_index=%d", THREAD); 1967 1968 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1969 ("type_name_index=%d const_name_index=%d", type_name_index, 1970 const_name_index)); 1971 } break; 1972 1973 case 'c': 1974 { 1975 // for the above tag value, value.class_info_index is right union field 1976 1977 if ((byte_i_ref + 2) > annotations_typeArray->length()) { 1978 // not enough room for a class_info_index 1979 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1980 ("length() is too small for a class_info_index")); 1981 return false; 1982 } 1983 1984 u2 class_info_index = rewrite_cp_ref_in_annotation_data( 1985 annotations_typeArray, byte_i_ref, 1986 "mapped old class_info_index=%d", THREAD); 1987 1988 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 1989 ("class_info_index=%d", class_info_index)); 1990 } break; 1991 1992 case '@': 1993 // For the above tag value, value.attr_value is the right union 1994 // field. This is a nested annotation. 1995 if (!rewrite_cp_refs_in_annotation_struct(annotations_typeArray, 1996 byte_i_ref, THREAD)) { 1997 // propagate failure back to caller 1998 return false; 1999 } 2000 break; 2001 2002 case '[': 2003 { 2004 if ((byte_i_ref + 2) > annotations_typeArray->length()) { 2005 // not enough room for a num_values field 2006 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 2007 ("length() is too small for a num_values field")); 2008 return false; 2009 } 2010 2011 // For the above tag value, value.array_value is the right union 2012 // field. This is an array of nested element_value. 2013 u2 num_values = Bytes::get_Java_u2((address) 2014 annotations_typeArray->adr_at(byte_i_ref)); 2015 byte_i_ref += 2; 2016 RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("num_values=%d", num_values)); 2017 2018 int calc_num_values = 0; 2019 for (; calc_num_values < num_values; calc_num_values++) { 2020 if (!rewrite_cp_refs_in_element_value( 2021 annotations_typeArray, byte_i_ref, THREAD)) { 2022 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 2023 ("bad nested element_value at %d", calc_num_values)); 2024 // propagate failure back to caller 2025 return false; 2026 } 2027 } 2028 assert(num_values == calc_num_values, "sanity check"); 2029 } break; 2030 2031 default: 2032 RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("bad tag=0x%x", tag)); 2033 return false; 2034 } // end decode tag field 2035 2036 return true; 2037 } // end rewrite_cp_refs_in_element_value() 2038 2039 2040 // Rewrite constant pool references in a fields_annotations field. 2041 bool VM_RedefineClasses::rewrite_cp_refs_in_fields_annotations( 2042 instanceKlassHandle scratch_class, TRAPS) { 2043 2044 Array<AnnotationArray*>* fields_annotations = scratch_class->fields_annotations(); 2045 2046 if (fields_annotations == NULL || fields_annotations->length() == 0) { 2047 // no fields_annotations so nothing to do 2048 return true; 2049 } 2050 2051 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 2052 ("fields_annotations length=%d", fields_annotations->length())); 2053 2054 for (int i = 0; i < fields_annotations->length(); i++) { 2055 AnnotationArray* field_annotations = fields_annotations->at(i); 2056 if (field_annotations == NULL || field_annotations->length() == 0) { 2057 // this field does not have any annotations so skip it 2058 continue; 2059 } 2060 2061 int byte_i = 0; // byte index into field_annotations 2062 if (!rewrite_cp_refs_in_annotations_typeArray(field_annotations, byte_i, 2063 THREAD)) { 2064 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 2065 ("bad field_annotations at %d", i)); 2066 // propagate failure back to caller 2067 return false; 2068 } 2069 } 2070 2071 return true; 2072 } // end rewrite_cp_refs_in_fields_annotations() 2073 2074 2075 // Rewrite constant pool references in a methods_annotations field. 2076 bool VM_RedefineClasses::rewrite_cp_refs_in_methods_annotations( 2077 instanceKlassHandle scratch_class, TRAPS) { 2078 2079 for (int i = 0; i < scratch_class->methods()->length(); i++) { 2080 Method* m = scratch_class->methods()->at(i); 2081 AnnotationArray* method_annotations = m->constMethod()->method_annotations(); 2082 2083 if (method_annotations == NULL || method_annotations->length() == 0) { 2084 // this method does not have any annotations so skip it 2085 continue; 2086 } 2087 2088 int byte_i = 0; // byte index into method_annotations 2089 if (!rewrite_cp_refs_in_annotations_typeArray(method_annotations, byte_i, 2090 THREAD)) { 2091 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 2092 ("bad method_annotations at %d", i)); 2093 // propagate failure back to caller 2094 return false; 2095 } 2096 } 2097 2098 return true; 2099 } // end rewrite_cp_refs_in_methods_annotations() 2100 2101 2102 // Rewrite constant pool references in a methods_parameter_annotations 2103 // field. This "structure" is adapted from the 2104 // RuntimeVisibleParameterAnnotations_attribute described in section 2105 // 4.8.17 of the 2nd-edition of the VM spec: 2106 // 2107 // methods_parameter_annotations_typeArray { 2108 // u1 num_parameters; 2109 // { 2110 // u2 num_annotations; 2111 // annotation annotations[num_annotations]; 2112 // } parameter_annotations[num_parameters]; 2113 // } 2114 // 2115 bool VM_RedefineClasses::rewrite_cp_refs_in_methods_parameter_annotations( 2116 instanceKlassHandle scratch_class, TRAPS) { 2117 2118 for (int i = 0; i < scratch_class->methods()->length(); i++) { 2119 Method* m = scratch_class->methods()->at(i); 2120 AnnotationArray* method_parameter_annotations = m->constMethod()->parameter_annotations(); 2121 if (method_parameter_annotations == NULL 2122 || method_parameter_annotations->length() == 0) { 2123 // this method does not have any parameter annotations so skip it 2124 continue; 2125 } 2126 2127 if (method_parameter_annotations->length() < 1) { 2128 // not enough room for a num_parameters field 2129 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 2130 ("length() is too small for a num_parameters field at %d", i)); 2131 return false; 2132 } 2133 2134 int byte_i = 0; // byte index into method_parameter_annotations 2135 2136 u1 num_parameters = method_parameter_annotations->at(byte_i); 2137 byte_i++; 2138 2139 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 2140 ("num_parameters=%d", num_parameters)); 2141 2142 int calc_num_parameters = 0; 2143 for (; calc_num_parameters < num_parameters; calc_num_parameters++) { 2144 if (!rewrite_cp_refs_in_annotations_typeArray( 2145 method_parameter_annotations, byte_i, THREAD)) { 2146 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 2147 ("bad method_parameter_annotations at %d", calc_num_parameters)); 2148 // propagate failure back to caller 2149 return false; 2150 } 2151 } 2152 assert(num_parameters == calc_num_parameters, "sanity check"); 2153 } 2154 2155 return true; 2156 } // end rewrite_cp_refs_in_methods_parameter_annotations() 2157 2158 2159 // Rewrite constant pool references in a methods_default_annotations 2160 // field. This "structure" is adapted from the AnnotationDefault_attribute 2161 // that is described in section 4.8.19 of the 2nd-edition of the VM spec: 2162 // 2163 // methods_default_annotations_typeArray { 2164 // element_value default_value; 2165 // } 2166 // 2167 bool VM_RedefineClasses::rewrite_cp_refs_in_methods_default_annotations( 2168 instanceKlassHandle scratch_class, TRAPS) { 2169 2170 for (int i = 0; i < scratch_class->methods()->length(); i++) { 2171 Method* m = scratch_class->methods()->at(i); 2172 AnnotationArray* method_default_annotations = m->constMethod()->default_annotations(); 2173 if (method_default_annotations == NULL 2174 || method_default_annotations->length() == 0) { 2175 // this method does not have any default annotations so skip it 2176 continue; 2177 } 2178 2179 int byte_i = 0; // byte index into method_default_annotations 2180 2181 if (!rewrite_cp_refs_in_element_value( 2182 method_default_annotations, byte_i, THREAD)) { 2183 RC_TRACE_WITH_THREAD(0x02000000, THREAD, 2184 ("bad default element_value at %d", i)); 2185 // propagate failure back to caller 2186 return false; 2187 } 2188 } 2189 2190 return true; 2191 } // end rewrite_cp_refs_in_methods_default_annotations() 2192 2193 2194 // Rewrite constant pool references in the method's stackmap table. 2195 // These "structures" are adapted from the StackMapTable_attribute that 2196 // is described in section 4.8.4 of the 6.0 version of the VM spec 2197 // (dated 2005.10.26): 2198 // file:///net/quincunx.sfbay/export/gbracha/ClassFile-Java6.pdf 2199 // 2200 // stack_map { 2201 // u2 number_of_entries; 2202 // stack_map_frame entries[number_of_entries]; 2203 // } 2204 // 2205 void VM_RedefineClasses::rewrite_cp_refs_in_stack_map_table( 2206 methodHandle method, TRAPS) { 2207 2208 if (!method->has_stackmap_table()) { 2209 return; 2210 } 2211 2212 AnnotationArray* stackmap_data = method->stackmap_data(); 2213 address stackmap_p = (address)stackmap_data->adr_at(0); 2214 address stackmap_end = stackmap_p + stackmap_data->length(); 2215 2216 assert(stackmap_p + 2 <= stackmap_end, "no room for number_of_entries"); 2217 u2 number_of_entries = Bytes::get_Java_u2(stackmap_p); 2218 stackmap_p += 2; 2219 2220 RC_TRACE_WITH_THREAD(0x04000000, THREAD, 2221 ("number_of_entries=%u", number_of_entries)); 2222 2223 // walk through each stack_map_frame 2224 u2 calc_number_of_entries = 0; 2225 for (; calc_number_of_entries < number_of_entries; calc_number_of_entries++) { 2226 // The stack_map_frame structure is a u1 frame_type followed by 2227 // 0 or more bytes of data: 2228 // 2229 // union stack_map_frame { 2230 // same_frame; 2231 // same_locals_1_stack_item_frame; 2232 // same_locals_1_stack_item_frame_extended; 2233 // chop_frame; 2234 // same_frame_extended; 2235 // append_frame; 2236 // full_frame; 2237 // } 2238 2239 assert(stackmap_p + 1 <= stackmap_end, "no room for frame_type"); 2240 // The Linux compiler does not like frame_type to be u1 or u2. It 2241 // issues the following warning for the first if-statement below: 2242 // 2243 // "warning: comparison is always true due to limited range of data type" 2244 // 2245 u4 frame_type = *stackmap_p; 2246 stackmap_p++; 2247 2248 // same_frame { 2249 // u1 frame_type = SAME; /* 0-63 */ 2250 // } 2251 if (frame_type >= 0 && frame_type <= 63) { 2252 // nothing more to do for same_frame 2253 } 2254 2255 // same_locals_1_stack_item_frame { 2256 // u1 frame_type = SAME_LOCALS_1_STACK_ITEM; /* 64-127 */ 2257 // verification_type_info stack[1]; 2258 // } 2259 else if (frame_type >= 64 && frame_type <= 127) { 2260 rewrite_cp_refs_in_verification_type_info(stackmap_p, stackmap_end, 2261 calc_number_of_entries, frame_type, THREAD); 2262 } 2263 2264 // reserved for future use 2265 else if (frame_type >= 128 && frame_type <= 246) { 2266 // nothing more to do for reserved frame_types 2267 } 2268 2269 // same_locals_1_stack_item_frame_extended { 2270 // u1 frame_type = SAME_LOCALS_1_STACK_ITEM_EXTENDED; /* 247 */ 2271 // u2 offset_delta; 2272 // verification_type_info stack[1]; 2273 // } 2274 else if (frame_type == 247) { 2275 stackmap_p += 2; 2276 rewrite_cp_refs_in_verification_type_info(stackmap_p, stackmap_end, 2277 calc_number_of_entries, frame_type, THREAD); 2278 } 2279 2280 // chop_frame { 2281 // u1 frame_type = CHOP; /* 248-250 */ 2282 // u2 offset_delta; 2283 // } 2284 else if (frame_type >= 248 && frame_type <= 250) { 2285 stackmap_p += 2; 2286 } 2287 2288 // same_frame_extended { 2289 // u1 frame_type = SAME_FRAME_EXTENDED; /* 251*/ 2290 // u2 offset_delta; 2291 // } 2292 else if (frame_type == 251) { 2293 stackmap_p += 2; 2294 } 2295 2296 // append_frame { 2297 // u1 frame_type = APPEND; /* 252-254 */ 2298 // u2 offset_delta; 2299 // verification_type_info locals[frame_type - 251]; 2300 // } 2301 else if (frame_type >= 252 && frame_type <= 254) { 2302 assert(stackmap_p + 2 <= stackmap_end, 2303 "no room for offset_delta"); 2304 stackmap_p += 2; 2305 u1 len = frame_type - 251; 2306 for (u1 i = 0; i < len; i++) { 2307 rewrite_cp_refs_in_verification_type_info(stackmap_p, stackmap_end, 2308 calc_number_of_entries, frame_type, THREAD); 2309 } 2310 } 2311 2312 // full_frame { 2313 // u1 frame_type = FULL_FRAME; /* 255 */ 2314 // u2 offset_delta; 2315 // u2 number_of_locals; 2316 // verification_type_info locals[number_of_locals]; 2317 // u2 number_of_stack_items; 2318 // verification_type_info stack[number_of_stack_items]; 2319 // } 2320 else if (frame_type == 255) { 2321 assert(stackmap_p + 2 + 2 <= stackmap_end, 2322 "no room for smallest full_frame"); 2323 stackmap_p += 2; 2324 2325 u2 number_of_locals = Bytes::get_Java_u2(stackmap_p); 2326 stackmap_p += 2; 2327 2328 for (u2 locals_i = 0; locals_i < number_of_locals; locals_i++) { 2329 rewrite_cp_refs_in_verification_type_info(stackmap_p, stackmap_end, 2330 calc_number_of_entries, frame_type, THREAD); 2331 } 2332 2333 // Use the largest size for the number_of_stack_items, but only get 2334 // the right number of bytes. 2335 u2 number_of_stack_items = Bytes::get_Java_u2(stackmap_p); 2336 stackmap_p += 2; 2337 2338 for (u2 stack_i = 0; stack_i < number_of_stack_items; stack_i++) { 2339 rewrite_cp_refs_in_verification_type_info(stackmap_p, stackmap_end, 2340 calc_number_of_entries, frame_type, THREAD); 2341 } 2342 } 2343 } // end while there is a stack_map_frame 2344 assert(number_of_entries == calc_number_of_entries, "sanity check"); 2345 } // end rewrite_cp_refs_in_stack_map_table() 2346 2347 2348 // Rewrite constant pool references in the verification type info 2349 // portion of the method's stackmap table. These "structures" are 2350 // adapted from the StackMapTable_attribute that is described in 2351 // section 4.8.4 of the 6.0 version of the VM spec (dated 2005.10.26): 2352 // file:///net/quincunx.sfbay/export/gbracha/ClassFile-Java6.pdf 2353 // 2354 // The verification_type_info structure is a u1 tag followed by 0 or 2355 // more bytes of data: 2356 // 2357 // union verification_type_info { 2358 // Top_variable_info; 2359 // Integer_variable_info; 2360 // Float_variable_info; 2361 // Long_variable_info; 2362 // Double_variable_info; 2363 // Null_variable_info; 2364 // UninitializedThis_variable_info; 2365 // Object_variable_info; 2366 // Uninitialized_variable_info; 2367 // } 2368 // 2369 void VM_RedefineClasses::rewrite_cp_refs_in_verification_type_info( 2370 address& stackmap_p_ref, address stackmap_end, u2 frame_i, 2371 u1 frame_type, TRAPS) { 2372 2373 assert(stackmap_p_ref + 1 <= stackmap_end, "no room for tag"); 2374 u1 tag = *stackmap_p_ref; 2375 stackmap_p_ref++; 2376 2377 switch (tag) { 2378 // Top_variable_info { 2379 // u1 tag = ITEM_Top; /* 0 */ 2380 // } 2381 // verificationType.hpp has zero as ITEM_Bogus instead of ITEM_Top 2382 case 0: // fall through 2383 2384 // Integer_variable_info { 2385 // u1 tag = ITEM_Integer; /* 1 */ 2386 // } 2387 case ITEM_Integer: // fall through 2388 2389 // Float_variable_info { 2390 // u1 tag = ITEM_Float; /* 2 */ 2391 // } 2392 case ITEM_Float: // fall through 2393 2394 // Double_variable_info { 2395 // u1 tag = ITEM_Double; /* 3 */ 2396 // } 2397 case ITEM_Double: // fall through 2398 2399 // Long_variable_info { 2400 // u1 tag = ITEM_Long; /* 4 */ 2401 // } 2402 case ITEM_Long: // fall through 2403 2404 // Null_variable_info { 2405 // u1 tag = ITEM_Null; /* 5 */ 2406 // } 2407 case ITEM_Null: // fall through 2408 2409 // UninitializedThis_variable_info { 2410 // u1 tag = ITEM_UninitializedThis; /* 6 */ 2411 // } 2412 case ITEM_UninitializedThis: 2413 // nothing more to do for the above tag types 2414 break; 2415 2416 // Object_variable_info { 2417 // u1 tag = ITEM_Object; /* 7 */ 2418 // u2 cpool_index; 2419 // } 2420 case ITEM_Object: 2421 { 2422 assert(stackmap_p_ref + 2 <= stackmap_end, "no room for cpool_index"); 2423 u2 cpool_index = Bytes::get_Java_u2(stackmap_p_ref); 2424 u2 new_cp_index = find_new_index(cpool_index); 2425 if (new_cp_index != 0) { 2426 RC_TRACE_WITH_THREAD(0x04000000, THREAD, 2427 ("mapped old cpool_index=%d", cpool_index)); 2428 Bytes::put_Java_u2(stackmap_p_ref, new_cp_index); 2429 cpool_index = new_cp_index; 2430 } 2431 stackmap_p_ref += 2; 2432 2433 RC_TRACE_WITH_THREAD(0x04000000, THREAD, 2434 ("frame_i=%u, frame_type=%u, cpool_index=%d", frame_i, 2435 frame_type, cpool_index)); 2436 } break; 2437 2438 // Uninitialized_variable_info { 2439 // u1 tag = ITEM_Uninitialized; /* 8 */ 2440 // u2 offset; 2441 // } 2442 case ITEM_Uninitialized: 2443 assert(stackmap_p_ref + 2 <= stackmap_end, "no room for offset"); 2444 stackmap_p_ref += 2; 2445 break; 2446 2447 default: 2448 RC_TRACE_WITH_THREAD(0x04000000, THREAD, 2449 ("frame_i=%u, frame_type=%u, bad tag=0x%x", frame_i, frame_type, tag)); 2450 ShouldNotReachHere(); 2451 break; 2452 } // end switch (tag) 2453 } // end rewrite_cp_refs_in_verification_type_info() 2454 2455 2456 // Change the constant pool associated with klass scratch_class to 2457 // scratch_cp. If shrink is true, then scratch_cp_length elements 2458 // are copied from scratch_cp to a smaller constant pool and the 2459 // smaller constant pool is associated with scratch_class. 2460 void VM_RedefineClasses::set_new_constant_pool( 2461 ClassLoaderData* loader_data, 2462 instanceKlassHandle scratch_class, constantPoolHandle scratch_cp, 2463 int scratch_cp_length, TRAPS) { 2464 assert(scratch_cp->length() >= scratch_cp_length, "sanity check"); 2465 2466 // scratch_cp is a merged constant pool and has enough space for a 2467 // worst case merge situation. We want to associate the minimum 2468 // sized constant pool with the klass to save space. 2469 constantPoolHandle smaller_cp(THREAD, 2470 ConstantPool::allocate(loader_data, scratch_cp_length, THREAD)); 2471 2472 // preserve version() value in the smaller copy 2473 int version = scratch_cp->version(); 2474 assert(version != 0, "sanity check"); 2475 smaller_cp->set_version(version); 2476 2477 // attach klass to new constant pool 2478 // reference to the cp holder is needed for copy_operands() 2479 smaller_cp->set_pool_holder(scratch_class()); 2480 2481 scratch_cp->copy_cp_to(1, scratch_cp_length - 1, smaller_cp, 1, THREAD); 2482 scratch_cp = smaller_cp; 2483 2484 // attach new constant pool to klass 2485 scratch_class->set_constants(scratch_cp()); 2486 2487 int i; // for portability 2488 2489 // update each field in klass to use new constant pool indices as needed 2490 for (JavaFieldStream fs(scratch_class); !fs.done(); fs.next()) { 2491 jshort cur_index = fs.name_index(); 2492 jshort new_index = find_new_index(cur_index); 2493 if (new_index != 0) { 2494 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 2495 ("field-name_index change: %d to %d", cur_index, new_index)); 2496 fs.set_name_index(new_index); 2497 } 2498 cur_index = fs.signature_index(); 2499 new_index = find_new_index(cur_index); 2500 if (new_index != 0) { 2501 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 2502 ("field-signature_index change: %d to %d", cur_index, new_index)); 2503 fs.set_signature_index(new_index); 2504 } 2505 cur_index = fs.initval_index(); 2506 new_index = find_new_index(cur_index); 2507 if (new_index != 0) { 2508 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 2509 ("field-initval_index change: %d to %d", cur_index, new_index)); 2510 fs.set_initval_index(new_index); 2511 } 2512 cur_index = fs.generic_signature_index(); 2513 new_index = find_new_index(cur_index); 2514 if (new_index != 0) { 2515 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 2516 ("field-generic_signature change: %d to %d", cur_index, new_index)); 2517 fs.set_generic_signature_index(new_index); 2518 } 2519 } // end for each field 2520 2521 // Update constant pool indices in the inner classes info to use 2522 // new constant indices as needed. The inner classes info is a 2523 // quadruple: 2524 // (inner_class_info, outer_class_info, inner_name, inner_access_flags) 2525 InnerClassesIterator iter(scratch_class); 2526 for (; !iter.done(); iter.next()) { 2527 int cur_index = iter.inner_class_info_index(); 2528 if (cur_index == 0) { 2529 continue; // JVM spec. allows null inner class refs so skip it 2530 } 2531 int new_index = find_new_index(cur_index); 2532 if (new_index != 0) { 2533 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 2534 ("inner_class_info change: %d to %d", cur_index, new_index)); 2535 iter.set_inner_class_info_index(new_index); 2536 } 2537 cur_index = iter.outer_class_info_index(); 2538 new_index = find_new_index(cur_index); 2539 if (new_index != 0) { 2540 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 2541 ("outer_class_info change: %d to %d", cur_index, new_index)); 2542 iter.set_outer_class_info_index(new_index); 2543 } 2544 cur_index = iter.inner_name_index(); 2545 new_index = find_new_index(cur_index); 2546 if (new_index != 0) { 2547 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 2548 ("inner_name change: %d to %d", cur_index, new_index)); 2549 iter.set_inner_name_index(new_index); 2550 } 2551 } // end for each inner class 2552 2553 // Attach each method in klass to the new constant pool and update 2554 // to use new constant pool indices as needed: 2555 Array<Method*>* methods = scratch_class->methods(); 2556 for (i = methods->length() - 1; i >= 0; i--) { 2557 methodHandle method(THREAD, methods->at(i)); 2558 method->set_constants(scratch_cp()); 2559 2560 int new_index = find_new_index(method->name_index()); 2561 if (new_index != 0) { 2562 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 2563 ("method-name_index change: %d to %d", method->name_index(), 2564 new_index)); 2565 method->set_name_index(new_index); 2566 } 2567 new_index = find_new_index(method->signature_index()); 2568 if (new_index != 0) { 2569 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 2570 ("method-signature_index change: %d to %d", 2571 method->signature_index(), new_index)); 2572 method->set_signature_index(new_index); 2573 } 2574 new_index = find_new_index(method->generic_signature_index()); 2575 if (new_index != 0) { 2576 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 2577 ("method-generic_signature_index change: %d to %d", 2578 method->generic_signature_index(), new_index)); 2579 method->set_generic_signature_index(new_index); 2580 } 2581 2582 // Update constant pool indices in the method's checked exception 2583 // table to use new constant indices as needed. 2584 int cext_length = method->checked_exceptions_length(); 2585 if (cext_length > 0) { 2586 CheckedExceptionElement * cext_table = 2587 method->checked_exceptions_start(); 2588 for (int j = 0; j < cext_length; j++) { 2589 int cur_index = cext_table[j].class_cp_index; 2590 int new_index = find_new_index(cur_index); 2591 if (new_index != 0) { 2592 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 2593 ("cext-class_cp_index change: %d to %d", cur_index, new_index)); 2594 cext_table[j].class_cp_index = (u2)new_index; 2595 } 2596 } // end for each checked exception table entry 2597 } // end if there are checked exception table entries 2598 2599 // Update each catch type index in the method's exception table 2600 // to use new constant pool indices as needed. The exception table 2601 // holds quadruple entries of the form: 2602 // (beg_bci, end_bci, handler_bci, klass_index) 2603 2604 ExceptionTable ex_table(method()); 2605 int ext_length = ex_table.length(); 2606 2607 for (int j = 0; j < ext_length; j ++) { 2608 int cur_index = ex_table.catch_type_index(j); 2609 int new_index = find_new_index(cur_index); 2610 if (new_index != 0) { 2611 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 2612 ("ext-klass_index change: %d to %d", cur_index, new_index)); 2613 ex_table.set_catch_type_index(j, new_index); 2614 } 2615 } // end for each exception table entry 2616 2617 // Update constant pool indices in the method's local variable 2618 // table to use new constant indices as needed. The local variable 2619 // table hold sextuple entries of the form: 2620 // (start_pc, length, name_index, descriptor_index, signature_index, slot) 2621 int lvt_length = method->localvariable_table_length(); 2622 if (lvt_length > 0) { 2623 LocalVariableTableElement * lv_table = 2624 method->localvariable_table_start(); 2625 for (int j = 0; j < lvt_length; j++) { 2626 int cur_index = lv_table[j].name_cp_index; 2627 int new_index = find_new_index(cur_index); 2628 if (new_index != 0) { 2629 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 2630 ("lvt-name_cp_index change: %d to %d", cur_index, new_index)); 2631 lv_table[j].name_cp_index = (u2)new_index; 2632 } 2633 cur_index = lv_table[j].descriptor_cp_index; 2634 new_index = find_new_index(cur_index); 2635 if (new_index != 0) { 2636 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 2637 ("lvt-descriptor_cp_index change: %d to %d", cur_index, 2638 new_index)); 2639 lv_table[j].descriptor_cp_index = (u2)new_index; 2640 } 2641 cur_index = lv_table[j].signature_cp_index; 2642 new_index = find_new_index(cur_index); 2643 if (new_index != 0) { 2644 RC_TRACE_WITH_THREAD(0x00080000, THREAD, 2645 ("lvt-signature_cp_index change: %d to %d", cur_index, new_index)); 2646 lv_table[j].signature_cp_index = (u2)new_index; 2647 } 2648 } // end for each local variable table entry 2649 } // end if there are local variable table entries 2650 2651 rewrite_cp_refs_in_stack_map_table(method, THREAD); 2652 } // end for each method 2653 } // end set_new_constant_pool() 2654 2655 2656 void VM_RedefineClasses::adjust_array_vtable(Klass* k_oop) { 2657 ArrayKlass* ak = ArrayKlass::cast(k_oop); 2658 bool trace_name_printed = false; 2659 ak->vtable()->adjust_method_entries(_matching_old_methods, 2660 _matching_new_methods, 2661 _matching_methods_length, 2662 &trace_name_printed); 2663 } 2664 2665 // Unevolving classes may point to methods of the_class directly 2666 // from their constant pool caches, itables, and/or vtables. We 2667 // use the SystemDictionary::classes_do() facility and this helper 2668 // to fix up these pointers. 2669 // 2670 // Note: We currently don't support updating the vtable in 2671 // arrayKlassOops. See Open Issues in jvmtiRedefineClasses.hpp. 2672 void VM_RedefineClasses::adjust_cpool_cache_and_vtable(Klass* k_oop, 2673 ClassLoaderData* initiating_loader, 2674 TRAPS) { 2675 Klass *k = k_oop; 2676 if (k->oop_is_instance()) { 2677 HandleMark hm(THREAD); 2678 InstanceKlass *ik = (InstanceKlass *) k; 2679 2680 // HotSpot specific optimization! HotSpot does not currently 2681 // support delegation from the bootstrap class loader to a 2682 // user-defined class loader. This means that if the bootstrap 2683 // class loader is the initiating class loader, then it will also 2684 // be the defining class loader. This also means that classes 2685 // loaded by the bootstrap class loader cannot refer to classes 2686 // loaded by a user-defined class loader. Note: a user-defined 2687 // class loader can delegate to the bootstrap class loader. 2688 // 2689 // If the current class being redefined has a user-defined class 2690 // loader as its defining class loader, then we can skip all 2691 // classes loaded by the bootstrap class loader. 2692 bool is_user_defined = 2693 InstanceKlass::cast(_the_class_oop)->class_loader() != NULL; 2694 if (is_user_defined && ik->class_loader() == NULL) { 2695 return; 2696 } 2697 2698 // If the class being redefined is java.lang.Object, we need to fix all 2699 // array class vtables also 2700 if (_the_class_oop == SystemDictionary::Object_klass()) { 2701 ik->array_klasses_do(adjust_array_vtable); 2702 } 2703 2704 // This is a very busy routine. We don't want too much tracing 2705 // printed out. 2706 bool trace_name_printed = false; 2707 2708 // Very noisy: only enable this call if you are trying to determine 2709 // that a specific class gets found by this routine. 2710 // RC_TRACE macro has an embedded ResourceMark 2711 // RC_TRACE_WITH_THREAD(0x00100000, THREAD, 2712 // ("adjust check: name=%s", ik->external_name())); 2713 // trace_name_printed = true; 2714 2715 // Fix the vtable embedded in the_class and subclasses of the_class, 2716 // if one exists. We discard scratch_class and we don't keep an 2717 // InstanceKlass around to hold obsolete methods so we don't have 2718 // any other InstanceKlass embedded vtables to update. The vtable 2719 // holds the Method*s for virtual (but not final) methods. 2720 if (ik->vtable_length() > 0 && ik->is_subtype_of(_the_class_oop)) { 2721 // ik->vtable() creates a wrapper object; rm cleans it up 2722 ResourceMark rm(THREAD); 2723 ik->vtable()->adjust_method_entries(_matching_old_methods, 2724 _matching_new_methods, 2725 _matching_methods_length, 2726 &trace_name_printed); 2727 } 2728 2729 // If the current class has an itable and we are either redefining an 2730 // interface or if the current class is a subclass of the_class, then 2731 // we potentially have to fix the itable. If we are redefining an 2732 // interface, then we have to call adjust_method_entries() for 2733 // every InstanceKlass that has an itable since there isn't a 2734 // subclass relationship between an interface and an InstanceKlass. 2735 if (ik->itable_length() > 0 && (_the_class_oop->is_interface() 2736 || ik->is_subclass_of(_the_class_oop))) { 2737 // ik->itable() creates a wrapper object; rm cleans it up 2738 ResourceMark rm(THREAD); 2739 ik->itable()->adjust_method_entries(_matching_old_methods, 2740 _matching_new_methods, 2741 _matching_methods_length, 2742 &trace_name_printed); 2743 } 2744 2745 // The constant pools in other classes (other_cp) can refer to 2746 // methods in the_class. We have to update method information in 2747 // other_cp's cache. If other_cp has a previous version, then we 2748 // have to repeat the process for each previous version. The 2749 // constant pool cache holds the Method*s for non-virtual 2750 // methods and for virtual, final methods. 2751 // 2752 // Special case: if the current class is the_class, then new_cp 2753 // has already been attached to the_class and old_cp has already 2754 // been added as a previous version. The new_cp doesn't have any 2755 // cached references to old methods so it doesn't need to be 2756 // updated. We can simply start with the previous version(s) in 2757 // that case. 2758 constantPoolHandle other_cp; 2759 ConstantPoolCache* cp_cache; 2760 2761 if (k_oop != _the_class_oop) { 2762 // this klass' constant pool cache may need adjustment 2763 other_cp = constantPoolHandle(ik->constants()); 2764 cp_cache = other_cp->cache(); 2765 if (cp_cache != NULL) { 2766 cp_cache->adjust_method_entries(_matching_old_methods, 2767 _matching_new_methods, 2768 _matching_methods_length, 2769 &trace_name_printed); 2770 } 2771 } 2772 { 2773 ResourceMark rm(THREAD); 2774 // PreviousVersionInfo objects returned via PreviousVersionWalker 2775 // contain a GrowableArray of handles. We have to clean up the 2776 // GrowableArray _after_ the PreviousVersionWalker destructor 2777 // has destroyed the handles. 2778 { 2779 // the previous versions' constant pool caches may need adjustment 2780 PreviousVersionWalker pvw(ik); 2781 for (PreviousVersionInfo * pv_info = pvw.next_previous_version(); 2782 pv_info != NULL; pv_info = pvw.next_previous_version()) { 2783 other_cp = pv_info->prev_constant_pool_handle(); 2784 cp_cache = other_cp->cache(); 2785 if (cp_cache != NULL) { 2786 cp_cache->adjust_method_entries(_matching_old_methods, 2787 _matching_new_methods, 2788 _matching_methods_length, 2789 &trace_name_printed); 2790 } 2791 } 2792 } // pvw is cleaned up 2793 } // rm is cleaned up 2794 } 2795 } 2796 2797 void VM_RedefineClasses::update_jmethod_ids() { 2798 for (int j = 0; j < _matching_methods_length; ++j) { 2799 Method* old_method = _matching_old_methods[j]; 2800 jmethodID jmid = old_method->find_jmethod_id_or_null(); 2801 if (jmid != NULL) { 2802 // There is a jmethodID, change it to point to the new method 2803 methodHandle new_method_h(_matching_new_methods[j]); 2804 Method::change_method_associated_with_jmethod_id(jmid, new_method_h()); 2805 assert(Method::resolve_jmethod_id(jmid) == _matching_new_methods[j], 2806 "should be replaced"); 2807 } 2808 } 2809 } 2810 2811 void VM_RedefineClasses::check_methods_and_mark_as_obsolete( 2812 BitMap *emcp_methods, int * emcp_method_count_p) { 2813 *emcp_method_count_p = 0; 2814 int obsolete_count = 0; 2815 int old_index = 0; 2816 for (int j = 0; j < _matching_methods_length; ++j, ++old_index) { 2817 Method* old_method = _matching_old_methods[j]; 2818 Method* new_method = _matching_new_methods[j]; 2819 Method* old_array_method; 2820 2821 // Maintain an old_index into the _old_methods array by skipping 2822 // deleted methods 2823 while ((old_array_method = _old_methods->at(old_index)) != old_method) { 2824 ++old_index; 2825 } 2826 2827 if (MethodComparator::methods_EMCP(old_method, new_method)) { 2828 // The EMCP definition from JSR-163 requires the bytecodes to be 2829 // the same with the exception of constant pool indices which may 2830 // differ. However, the constants referred to by those indices 2831 // must be the same. 2832 // 2833 // We use methods_EMCP() for comparison since constant pool 2834 // merging can remove duplicate constant pool entries that were 2835 // present in the old method and removed from the rewritten new 2836 // method. A faster binary comparison function would consider the 2837 // old and new methods to be different when they are actually 2838 // EMCP. 2839 // 2840 // The old and new methods are EMCP and you would think that we 2841 // could get rid of one of them here and now and save some space. 2842 // However, the concept of EMCP only considers the bytecodes and 2843 // the constant pool entries in the comparison. Other things, 2844 // e.g., the line number table (LNT) or the local variable table 2845 // (LVT) don't count in the comparison. So the new (and EMCP) 2846 // method can have a new LNT that we need so we can't just 2847 // overwrite the new method with the old method. 2848 // 2849 // When this routine is called, we have already attached the new 2850 // methods to the_class so the old methods are effectively 2851 // overwritten. However, if an old method is still executing, 2852 // then the old method cannot be collected until sometime after 2853 // the old method call has returned. So the overwriting of old 2854 // methods by new methods will save us space except for those 2855 // (hopefully few) old methods that are still executing. 2856 // 2857 // A method refers to a ConstMethod* and this presents another 2858 // possible avenue to space savings. The ConstMethod* in the 2859 // new method contains possibly new attributes (LNT, LVT, etc). 2860 // At first glance, it seems possible to save space by replacing 2861 // the ConstMethod* in the old method with the ConstMethod* 2862 // from the new method. The old and new methods would share the 2863 // same ConstMethod* and we would save the space occupied by 2864 // the old ConstMethod*. However, the ConstMethod* contains 2865 // a back reference to the containing method. Sharing the 2866 // ConstMethod* between two methods could lead to confusion in 2867 // the code that uses the back reference. This would lead to 2868 // brittle code that could be broken in non-obvious ways now or 2869 // in the future. 2870 // 2871 // Another possibility is to copy the ConstMethod* from the new 2872 // method to the old method and then overwrite the new method with 2873 // the old method. Since the ConstMethod* contains the bytecodes 2874 // for the method embedded in the oop, this option would change 2875 // the bytecodes out from under any threads executing the old 2876 // method and make the thread's bcp invalid. Since EMCP requires 2877 // that the bytecodes be the same modulo constant pool indices, it 2878 // is straight forward to compute the correct new bcp in the new 2879 // ConstMethod* from the old bcp in the old ConstMethod*. The 2880 // time consuming part would be searching all the frames in all 2881 // of the threads to find all of the calls to the old method. 2882 // 2883 // It looks like we will have to live with the limited savings 2884 // that we get from effectively overwriting the old methods 2885 // when the new methods are attached to the_class. 2886 2887 // track which methods are EMCP for add_previous_version() call 2888 emcp_methods->set_bit(old_index); 2889 (*emcp_method_count_p)++; 2890 2891 // An EMCP method is _not_ obsolete. An obsolete method has a 2892 // different jmethodID than the current method. An EMCP method 2893 // has the same jmethodID as the current method. Having the 2894 // same jmethodID for all EMCP versions of a method allows for 2895 // a consistent view of the EMCP methods regardless of which 2896 // EMCP method you happen to have in hand. For example, a 2897 // breakpoint set in one EMCP method will work for all EMCP 2898 // versions of the method including the current one. 2899 } else { 2900 // mark obsolete methods as such 2901 old_method->set_is_obsolete(); 2902 obsolete_count++; 2903 2904 // obsolete methods need a unique idnum 2905 u2 num = InstanceKlass::cast(_the_class_oop)->next_method_idnum(); 2906 if (num != ConstMethod::UNSET_IDNUM) { 2907 // u2 old_num = old_method->method_idnum(); 2908 old_method->set_method_idnum(num); 2909 // TO DO: attach obsolete annotations to obsolete method's new idnum 2910 } 2911 // With tracing we try not to "yack" too much. The position of 2912 // this trace assumes there are fewer obsolete methods than 2913 // EMCP methods. 2914 RC_TRACE(0x00000100, ("mark %s(%s) as obsolete", 2915 old_method->name()->as_C_string(), 2916 old_method->signature()->as_C_string())); 2917 } 2918 old_method->set_is_old(); 2919 } 2920 for (int i = 0; i < _deleted_methods_length; ++i) { 2921 Method* old_method = _deleted_methods[i]; 2922 2923 assert(old_method->vtable_index() < 0, 2924 "cannot delete methods with vtable entries");; 2925 2926 // Mark all deleted methods as old and obsolete 2927 old_method->set_is_old(); 2928 old_method->set_is_obsolete(); 2929 ++obsolete_count; 2930 // With tracing we try not to "yack" too much. The position of 2931 // this trace assumes there are fewer obsolete methods than 2932 // EMCP methods. 2933 RC_TRACE(0x00000100, ("mark deleted %s(%s) as obsolete", 2934 old_method->name()->as_C_string(), 2935 old_method->signature()->as_C_string())); 2936 } 2937 assert((*emcp_method_count_p + obsolete_count) == _old_methods->length(), 2938 "sanity check"); 2939 RC_TRACE(0x00000100, ("EMCP_cnt=%d, obsolete_cnt=%d", *emcp_method_count_p, 2940 obsolete_count)); 2941 } 2942 2943 // This internal class transfers the native function registration from old methods 2944 // to new methods. It is designed to handle both the simple case of unchanged 2945 // native methods and the complex cases of native method prefixes being added and/or 2946 // removed. 2947 // It expects only to be used during the VM_RedefineClasses op (a safepoint). 2948 // 2949 // This class is used after the new methods have been installed in "the_class". 2950 // 2951 // So, for example, the following must be handled. Where 'm' is a method and 2952 // a number followed by an underscore is a prefix. 2953 // 2954 // Old Name New Name 2955 // Simple transfer to new method m -> m 2956 // Add prefix m -> 1_m 2957 // Remove prefix 1_m -> m 2958 // Simultaneous add of prefixes m -> 3_2_1_m 2959 // Simultaneous removal of prefixes 3_2_1_m -> m 2960 // Simultaneous add and remove 1_m -> 2_m 2961 // Same, caused by prefix removal only 3_2_1_m -> 3_2_m 2962 // 2963 class TransferNativeFunctionRegistration { 2964 private: 2965 instanceKlassHandle the_class; 2966 int prefix_count; 2967 char** prefixes; 2968 2969 // Recursively search the binary tree of possibly prefixed method names. 2970 // Iteration could be used if all agents were well behaved. Full tree walk is 2971 // more resilent to agents not cleaning up intermediate methods. 2972 // Branch at each depth in the binary tree is: 2973 // (1) without the prefix. 2974 // (2) with the prefix. 2975 // where 'prefix' is the prefix at that 'depth' (first prefix, second prefix,...) 2976 Method* search_prefix_name_space(int depth, char* name_str, size_t name_len, 2977 Symbol* signature) { 2978 TempNewSymbol name_symbol = SymbolTable::probe(name_str, (int)name_len); 2979 if (name_symbol != NULL) { 2980 Method* method = the_class()->lookup_method(name_symbol, signature); 2981 if (method != NULL) { 2982 // Even if prefixed, intermediate methods must exist. 2983 if (method->is_native()) { 2984 // Wahoo, we found a (possibly prefixed) version of the method, return it. 2985 return method; 2986 } 2987 if (depth < prefix_count) { 2988 // Try applying further prefixes (other than this one). 2989 method = search_prefix_name_space(depth+1, name_str, name_len, signature); 2990 if (method != NULL) { 2991 return method; // found 2992 } 2993 2994 // Try adding this prefix to the method name and see if it matches 2995 // another method name. 2996 char* prefix = prefixes[depth]; 2997 size_t prefix_len = strlen(prefix); 2998 size_t trial_len = name_len + prefix_len; 2999 char* trial_name_str = NEW_RESOURCE_ARRAY(char, trial_len + 1); 3000 strcpy(trial_name_str, prefix); 3001 strcat(trial_name_str, name_str); 3002 method = search_prefix_name_space(depth+1, trial_name_str, trial_len, 3003 signature); 3004 if (method != NULL) { 3005 // If found along this branch, it was prefixed, mark as such 3006 method->set_is_prefixed_native(); 3007 return method; // found 3008 } 3009 } 3010 } 3011 } 3012 return NULL; // This whole branch bore nothing 3013 } 3014 3015 // Return the method name with old prefixes stripped away. 3016 char* method_name_without_prefixes(Method* method) { 3017 Symbol* name = method->name(); 3018 char* name_str = name->as_utf8(); 3019 3020 // Old prefixing may be defunct, strip prefixes, if any. 3021 for (int i = prefix_count-1; i >= 0; i--) { 3022 char* prefix = prefixes[i]; 3023 size_t prefix_len = strlen(prefix); 3024 if (strncmp(prefix, name_str, prefix_len) == 0) { 3025 name_str += prefix_len; 3026 } 3027 } 3028 return name_str; 3029 } 3030 3031 // Strip any prefixes off the old native method, then try to find a 3032 // (possibly prefixed) new native that matches it. 3033 Method* strip_and_search_for_new_native(Method* method) { 3034 ResourceMark rm; 3035 char* name_str = method_name_without_prefixes(method); 3036 return search_prefix_name_space(0, name_str, strlen(name_str), 3037 method->signature()); 3038 } 3039 3040 public: 3041 3042 // Construct a native method transfer processor for this class. 3043 TransferNativeFunctionRegistration(instanceKlassHandle _the_class) { 3044 assert(SafepointSynchronize::is_at_safepoint(), "sanity check"); 3045 3046 the_class = _the_class; 3047 prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count); 3048 } 3049 3050 // Attempt to transfer any of the old or deleted methods that are native 3051 void transfer_registrations(Method** old_methods, int methods_length) { 3052 for (int j = 0; j < methods_length; j++) { 3053 Method* old_method = old_methods[j]; 3054 3055 if (old_method->is_native() && old_method->has_native_function()) { 3056 Method* new_method = strip_and_search_for_new_native(old_method); 3057 if (new_method != NULL) { 3058 // Actually set the native function in the new method. 3059 // Redefine does not send events (except CFLH), certainly not this 3060 // behind the scenes re-registration. 3061 new_method->set_native_function(old_method->native_function(), 3062 !Method::native_bind_event_is_interesting); 3063 } 3064 } 3065 } 3066 } 3067 }; 3068 3069 // Don't lose the association between a native method and its JNI function. 3070 void VM_RedefineClasses::transfer_old_native_function_registrations(instanceKlassHandle the_class) { 3071 TransferNativeFunctionRegistration transfer(the_class); 3072 transfer.transfer_registrations(_deleted_methods, _deleted_methods_length); 3073 transfer.transfer_registrations(_matching_old_methods, _matching_methods_length); 3074 } 3075 3076 // Deoptimize all compiled code that depends on this class. 3077 // 3078 // If the can_redefine_classes capability is obtained in the onload 3079 // phase then the compiler has recorded all dependencies from startup. 3080 // In that case we need only deoptimize and throw away all compiled code 3081 // that depends on the class. 3082 // 3083 // If can_redefine_classes is obtained sometime after the onload 3084 // phase then the dependency information may be incomplete. In that case 3085 // the first call to RedefineClasses causes all compiled code to be 3086 // thrown away. As can_redefine_classes has been obtained then 3087 // all future compilations will record dependencies so second and 3088 // subsequent calls to RedefineClasses need only throw away code 3089 // that depends on the class. 3090 // 3091 void VM_RedefineClasses::flush_dependent_code(instanceKlassHandle k_h, TRAPS) { 3092 assert_locked_or_safepoint(Compile_lock); 3093 3094 // All dependencies have been recorded from startup or this is a second or 3095 // subsequent use of RedefineClasses 3096 if (JvmtiExport::all_dependencies_are_recorded()) { 3097 Universe::flush_evol_dependents_on(k_h); 3098 } else { 3099 CodeCache::mark_all_nmethods_for_deoptimization(); 3100 3101 ResourceMark rm(THREAD); 3102 DeoptimizationMarker dm; 3103 3104 // Deoptimize all activations depending on marked nmethods 3105 Deoptimization::deoptimize_dependents(); 3106 3107 // Make the dependent methods not entrant (in VM_Deoptimize they are made zombies) 3108 CodeCache::make_marked_nmethods_not_entrant(); 3109 3110 // From now on we know that the dependency information is complete 3111 JvmtiExport::set_all_dependencies_are_recorded(true); 3112 } 3113 } 3114 3115 void VM_RedefineClasses::compute_added_deleted_matching_methods() { 3116 Method* old_method; 3117 Method* new_method; 3118 3119 _matching_old_methods = NEW_RESOURCE_ARRAY(Method*, _old_methods->length()); 3120 _matching_new_methods = NEW_RESOURCE_ARRAY(Method*, _old_methods->length()); 3121 _added_methods = NEW_RESOURCE_ARRAY(Method*, _new_methods->length()); 3122 _deleted_methods = NEW_RESOURCE_ARRAY(Method*, _old_methods->length()); 3123 3124 _matching_methods_length = 0; 3125 _deleted_methods_length = 0; 3126 _added_methods_length = 0; 3127 3128 int nj = 0; 3129 int oj = 0; 3130 while (true) { 3131 if (oj >= _old_methods->length()) { 3132 if (nj >= _new_methods->length()) { 3133 break; // we've looked at everything, done 3134 } 3135 // New method at the end 3136 new_method = _new_methods->at(nj); 3137 _added_methods[_added_methods_length++] = new_method; 3138 ++nj; 3139 } else if (nj >= _new_methods->length()) { 3140 // Old method, at the end, is deleted 3141 old_method = _old_methods->at(oj); 3142 _deleted_methods[_deleted_methods_length++] = old_method; 3143 ++oj; 3144 } else { 3145 old_method = _old_methods->at(oj); 3146 new_method = _new_methods->at(nj); 3147 if (old_method->name() == new_method->name()) { 3148 if (old_method->signature() == new_method->signature()) { 3149 _matching_old_methods[_matching_methods_length ] = old_method; 3150 _matching_new_methods[_matching_methods_length++] = new_method; 3151 ++nj; 3152 ++oj; 3153 } else { 3154 // added overloaded have already been moved to the end, 3155 // so this is a deleted overloaded method 3156 _deleted_methods[_deleted_methods_length++] = old_method; 3157 ++oj; 3158 } 3159 } else { // names don't match 3160 if (old_method->name()->fast_compare(new_method->name()) > 0) { 3161 // new method 3162 _added_methods[_added_methods_length++] = new_method; 3163 ++nj; 3164 } else { 3165 // deleted method 3166 _deleted_methods[_deleted_methods_length++] = old_method; 3167 ++oj; 3168 } 3169 } 3170 } 3171 } 3172 assert(_matching_methods_length + _deleted_methods_length == _old_methods->length(), "sanity"); 3173 assert(_matching_methods_length + _added_methods_length == _new_methods->length(), "sanity"); 3174 } 3175 3176 3177 void VM_RedefineClasses::swap_annotations(instanceKlassHandle the_class, 3178 instanceKlassHandle scratch_class) { 3179 // Since there is currently no rewriting of type annotations indexes 3180 // into the CP, we null out type annotations on scratch_class before 3181 // we swap annotations with the_class rather than facing the 3182 // possibility of shipping annotations with broken indexes to 3183 // Java-land. 3184 ClassLoaderData* loader_data = scratch_class->class_loader_data(); 3185 AnnotationArray* new_class_type_annotations = scratch_class->class_type_annotations(); 3186 if (new_class_type_annotations != NULL) { 3187 MetadataFactory::free_array<u1>(loader_data, new_class_type_annotations); 3188 scratch_class->annotations()->set_class_type_annotations(NULL); 3189 } 3190 Array<AnnotationArray*>* new_field_type_annotations = scratch_class->fields_type_annotations(); 3191 if (new_field_type_annotations != NULL) { 3192 Annotations::free_contents(loader_data, new_field_type_annotations); 3193 scratch_class->annotations()->set_fields_type_annotations(NULL); 3194 } 3195 3196 // Swap annotation fields values 3197 Annotations* old_annotations = the_class->annotations(); 3198 the_class->set_annotations(scratch_class->annotations()); 3199 scratch_class->set_annotations(old_annotations); 3200 } 3201 3202 3203 // Install the redefinition of a class: 3204 // - house keeping (flushing breakpoints and caches, deoptimizing 3205 // dependent compiled code) 3206 // - replacing parts in the_class with parts from scratch_class 3207 // - adding a weak reference to track the obsolete but interesting 3208 // parts of the_class 3209 // - adjusting constant pool caches and vtables in other classes 3210 // that refer to methods in the_class. These adjustments use the 3211 // SystemDictionary::classes_do() facility which only allows 3212 // a helper method to be specified. The interesting parameters 3213 // that we would like to pass to the helper method are saved in 3214 // static global fields in the VM operation. 3215 void VM_RedefineClasses::redefine_single_class(jclass the_jclass, 3216 Klass* scratch_class_oop, TRAPS) { 3217 3218 HandleMark hm(THREAD); // make sure handles from this call are freed 3219 RC_TIMER_START(_timer_rsc_phase1); 3220 3221 instanceKlassHandle scratch_class(scratch_class_oop); 3222 3223 oop the_class_mirror = JNIHandles::resolve_non_null(the_jclass); 3224 Klass* the_class_oop = java_lang_Class::as_Klass(the_class_mirror); 3225 instanceKlassHandle the_class = instanceKlassHandle(THREAD, the_class_oop); 3226 3227 // Remove all breakpoints in methods of this class 3228 JvmtiBreakpoints& jvmti_breakpoints = JvmtiCurrentBreakpoints::get_jvmti_breakpoints(); 3229 jvmti_breakpoints.clearall_in_class_at_safepoint(the_class_oop); 3230 3231 if (the_class_oop == Universe::reflect_invoke_cache()->klass()) { 3232 // We are redefining java.lang.reflect.Method. Method.invoke() is 3233 // cached and users of the cache care about each active version of 3234 // the method so we have to track this previous version. 3235 // Do this before methods get switched 3236 Universe::reflect_invoke_cache()->add_previous_version( 3237 the_class->method_with_idnum(Universe::reflect_invoke_cache()->method_idnum())); 3238 } 3239 3240 // Deoptimize all compiled code that depends on this class 3241 flush_dependent_code(the_class, THREAD); 3242 3243 _old_methods = the_class->methods(); 3244 _new_methods = scratch_class->methods(); 3245 _the_class_oop = the_class_oop; 3246 compute_added_deleted_matching_methods(); 3247 update_jmethod_ids(); 3248 3249 // Attach new constant pool to the original klass. The original 3250 // klass still refers to the old constant pool (for now). 3251 scratch_class->constants()->set_pool_holder(the_class()); 3252 3253 #if 0 3254 // In theory, with constant pool merging in place we should be able 3255 // to save space by using the new, merged constant pool in place of 3256 // the old constant pool(s). By "pool(s)" I mean the constant pool in 3257 // the klass version we are replacing now and any constant pool(s) in 3258 // previous versions of klass. Nice theory, doesn't work in practice. 3259 // When this code is enabled, even simple programs throw NullPointer 3260 // exceptions. I'm guessing that this is caused by some constant pool 3261 // cache difference between the new, merged constant pool and the 3262 // constant pool that was just being used by the klass. I'm keeping 3263 // this code around to archive the idea, but the code has to remain 3264 // disabled for now. 3265 3266 // Attach each old method to the new constant pool. This can be 3267 // done here since we are past the bytecode verification and 3268 // constant pool optimization phases. 3269 for (int i = _old_methods->length() - 1; i >= 0; i--) { 3270 Method* method = _old_methods->at(i); 3271 method->set_constants(scratch_class->constants()); 3272 } 3273 3274 { 3275 // walk all previous versions of the klass 3276 InstanceKlass *ik = (InstanceKlass *)the_class(); 3277 PreviousVersionWalker pvw(ik); 3278 instanceKlassHandle ikh; 3279 do { 3280 ikh = pvw.next_previous_version(); 3281 if (!ikh.is_null()) { 3282 ik = ikh(); 3283 3284 // attach previous version of klass to the new constant pool 3285 ik->set_constants(scratch_class->constants()); 3286 3287 // Attach each method in the previous version of klass to the 3288 // new constant pool 3289 Array<Method*>* prev_methods = ik->methods(); 3290 for (int i = prev_methods->length() - 1; i >= 0; i--) { 3291 Method* method = prev_methods->at(i); 3292 method->set_constants(scratch_class->constants()); 3293 } 3294 } 3295 } while (!ikh.is_null()); 3296 } 3297 #endif 3298 3299 // Replace methods and constantpool 3300 the_class->set_methods(_new_methods); 3301 scratch_class->set_methods(_old_methods); // To prevent potential GCing of the old methods, 3302 // and to be able to undo operation easily. 3303 3304 ConstantPool* old_constants = the_class->constants(); 3305 the_class->set_constants(scratch_class->constants()); 3306 scratch_class->set_constants(old_constants); // See the previous comment. 3307 #if 0 3308 // We are swapping the guts of "the new class" with the guts of "the 3309 // class". Since the old constant pool has just been attached to "the 3310 // new class", it seems logical to set the pool holder in the old 3311 // constant pool also. However, doing this will change the observable 3312 // class hierarchy for any old methods that are still executing. A 3313 // method can query the identity of its "holder" and this query uses 3314 // the method's constant pool link to find the holder. The change in 3315 // holding class from "the class" to "the new class" can confuse 3316 // things. 3317 // 3318 // Setting the old constant pool's holder will also cause 3319 // verification done during vtable initialization below to fail. 3320 // During vtable initialization, the vtable's class is verified to be 3321 // a subtype of the method's holder. The vtable's class is "the 3322 // class" and the method's holder is gotten from the constant pool 3323 // link in the method itself. For "the class"'s directly implemented 3324 // methods, the method holder is "the class" itself (as gotten from 3325 // the new constant pool). The check works fine in this case. The 3326 // check also works fine for methods inherited from super classes. 3327 // 3328 // Miranda methods are a little more complicated. A miranda method is 3329 // provided by an interface when the class implementing the interface 3330 // does not provide its own method. These interfaces are implemented 3331 // internally as an InstanceKlass. These special instanceKlasses 3332 // share the constant pool of the class that "implements" the 3333 // interface. By sharing the constant pool, the method holder of a 3334 // miranda method is the class that "implements" the interface. In a 3335 // non-redefine situation, the subtype check works fine. However, if 3336 // the old constant pool's pool holder is modified, then the check 3337 // fails because there is no class hierarchy relationship between the 3338 // vtable's class and "the new class". 3339 3340 old_constants->set_pool_holder(scratch_class()); 3341 #endif 3342 3343 // track which methods are EMCP for add_previous_version() call below 3344 BitMap emcp_methods(_old_methods->length()); 3345 int emcp_method_count = 0; 3346 emcp_methods.clear(); // clears 0..(length() - 1) 3347 check_methods_and_mark_as_obsolete(&emcp_methods, &emcp_method_count); 3348 transfer_old_native_function_registrations(the_class); 3349 3350 // The class file bytes from before any retransformable agents mucked 3351 // with them was cached on the scratch class, move to the_class. 3352 // Note: we still want to do this if nothing needed caching since it 3353 // should get cleared in the_class too. 3354 if (the_class->get_cached_class_file_bytes() == 0) { 3355 // the_class doesn't have a cache yet so copy it 3356 the_class->set_cached_class_file( 3357 scratch_class->get_cached_class_file_bytes(), 3358 scratch_class->get_cached_class_file_len()); 3359 } 3360 #ifndef PRODUCT 3361 else { 3362 assert(the_class->get_cached_class_file_bytes() == 3363 scratch_class->get_cached_class_file_bytes(), "cache ptrs must match"); 3364 assert(the_class->get_cached_class_file_len() == 3365 scratch_class->get_cached_class_file_len(), "cache lens must match"); 3366 } 3367 #endif 3368 3369 // Replace inner_classes 3370 Array<u2>* old_inner_classes = the_class->inner_classes(); 3371 the_class->set_inner_classes(scratch_class->inner_classes()); 3372 scratch_class->set_inner_classes(old_inner_classes); 3373 3374 // Initialize the vtable and interface table after 3375 // methods have been rewritten 3376 { 3377 ResourceMark rm(THREAD); 3378 // no exception should happen here since we explicitly 3379 // do not check loader constraints. 3380 // compare_and_normalize_class_versions has already checked: 3381 // - classloaders unchanged, signatures unchanged 3382 // - all instanceKlasses for redefined classes reused & contents updated 3383 the_class->vtable()->initialize_vtable(false, THREAD); 3384 the_class->itable()->initialize_itable(false, THREAD); 3385 assert(!HAS_PENDING_EXCEPTION || (THREAD->pending_exception()->is_a(SystemDictionary::ThreadDeath_klass())), "redefine exception"); 3386 } 3387 3388 // Leave arrays of jmethodIDs and itable index cache unchanged 3389 3390 // Copy the "source file name" attribute from new class version 3391 the_class->set_source_file_name(scratch_class->source_file_name()); 3392 3393 // Copy the "source debug extension" attribute from new class version 3394 the_class->set_source_debug_extension( 3395 scratch_class->source_debug_extension(), 3396 scratch_class->source_debug_extension() == NULL ? 0 : 3397 (int)strlen(scratch_class->source_debug_extension())); 3398 3399 // Use of javac -g could be different in the old and the new 3400 if (scratch_class->access_flags().has_localvariable_table() != 3401 the_class->access_flags().has_localvariable_table()) { 3402 3403 AccessFlags flags = the_class->access_flags(); 3404 if (scratch_class->access_flags().has_localvariable_table()) { 3405 flags.set_has_localvariable_table(); 3406 } else { 3407 flags.clear_has_localvariable_table(); 3408 } 3409 the_class->set_access_flags(flags); 3410 } 3411 3412 swap_annotations(the_class, scratch_class); 3413 3414 // Replace minor version number of class file 3415 u2 old_minor_version = the_class->minor_version(); 3416 the_class->set_minor_version(scratch_class->minor_version()); 3417 scratch_class->set_minor_version(old_minor_version); 3418 3419 // Replace major version number of class file 3420 u2 old_major_version = the_class->major_version(); 3421 the_class->set_major_version(scratch_class->major_version()); 3422 scratch_class->set_major_version(old_major_version); 3423 3424 // Replace CP indexes for class and name+type of enclosing method 3425 u2 old_class_idx = the_class->enclosing_method_class_index(); 3426 u2 old_method_idx = the_class->enclosing_method_method_index(); 3427 the_class->set_enclosing_method_indices( 3428 scratch_class->enclosing_method_class_index(), 3429 scratch_class->enclosing_method_method_index()); 3430 scratch_class->set_enclosing_method_indices(old_class_idx, old_method_idx); 3431 3432 // keep track of previous versions of this class 3433 the_class->add_previous_version(scratch_class, &emcp_methods, 3434 emcp_method_count); 3435 3436 RC_TIMER_STOP(_timer_rsc_phase1); 3437 RC_TIMER_START(_timer_rsc_phase2); 3438 3439 // Adjust constantpool caches and vtables for all classes 3440 // that reference methods of the evolved class. 3441 SystemDictionary::classes_do(adjust_cpool_cache_and_vtable, THREAD); 3442 3443 // Fix Resolution Error table also to remove old constant pools 3444 SystemDictionary::delete_resolution_error(old_constants); 3445 3446 if (the_class->oop_map_cache() != NULL) { 3447 // Flush references to any obsolete methods from the oop map cache 3448 // so that obsolete methods are not pinned. 3449 the_class->oop_map_cache()->flush_obsolete_entries(); 3450 } 3451 3452 // increment the classRedefinedCount field in the_class and in any 3453 // direct and indirect subclasses of the_class 3454 increment_class_counter((InstanceKlass *)the_class(), THREAD); 3455 3456 // RC_TRACE macro has an embedded ResourceMark 3457 RC_TRACE_WITH_THREAD(0x00000001, THREAD, 3458 ("redefined name=%s, count=%d (avail_mem=" UINT64_FORMAT "K)", 3459 the_class->external_name(), 3460 java_lang_Class::classRedefinedCount(the_class_mirror), 3461 os::available_memory() >> 10)); 3462 3463 RC_TIMER_STOP(_timer_rsc_phase2); 3464 } // end redefine_single_class() 3465 3466 3467 // Increment the classRedefinedCount field in the specific InstanceKlass 3468 // and in all direct and indirect subclasses. 3469 void VM_RedefineClasses::increment_class_counter(InstanceKlass *ik, TRAPS) { 3470 oop class_mirror = ik->java_mirror(); 3471 Klass* class_oop = java_lang_Class::as_Klass(class_mirror); 3472 int new_count = java_lang_Class::classRedefinedCount(class_mirror) + 1; 3473 java_lang_Class::set_classRedefinedCount(class_mirror, new_count); 3474 3475 if (class_oop != _the_class_oop) { 3476 // _the_class_oop count is printed at end of redefine_single_class() 3477 RC_TRACE_WITH_THREAD(0x00000008, THREAD, 3478 ("updated count in subclass=%s to %d", ik->external_name(), new_count)); 3479 } 3480 3481 for (Klass *subk = ik->subklass(); subk != NULL; 3482 subk = subk->next_sibling()) { 3483 if (subk->oop_is_instance()) { 3484 // Only update instanceKlasses 3485 InstanceKlass *subik = (InstanceKlass*)subk; 3486 // recursively do subclasses of the current subclass 3487 increment_class_counter(subik, THREAD); 3488 } 3489 } 3490 } 3491 3492 void VM_RedefineClasses::check_class(Klass* k_oop, 3493 ClassLoaderData* initiating_loader, 3494 TRAPS) { 3495 Klass *k = k_oop; 3496 if (k->oop_is_instance()) { 3497 HandleMark hm(THREAD); 3498 InstanceKlass *ik = (InstanceKlass *) k; 3499 bool no_old_methods = true; // be optimistic 3500 ResourceMark rm(THREAD); 3501 3502 // a vtable should never contain old or obsolete methods 3503 if (ik->vtable_length() > 0 && 3504 !ik->vtable()->check_no_old_or_obsolete_entries()) { 3505 if (RC_TRACE_ENABLED(0x00004000)) { 3506 RC_TRACE_WITH_THREAD(0x00004000, THREAD, 3507 ("klassVtable::check_no_old_or_obsolete_entries failure" 3508 " -- OLD or OBSOLETE method found -- class: %s", 3509 ik->signature_name())); 3510 ik->vtable()->dump_vtable(); 3511 } 3512 no_old_methods = false; 3513 } 3514 3515 // an itable should never contain old or obsolete methods 3516 if (ik->itable_length() > 0 && 3517 !ik->itable()->check_no_old_or_obsolete_entries()) { 3518 if (RC_TRACE_ENABLED(0x00004000)) { 3519 RC_TRACE_WITH_THREAD(0x00004000, THREAD, 3520 ("klassItable::check_no_old_or_obsolete_entries failure" 3521 " -- OLD or OBSOLETE method found -- class: %s", 3522 ik->signature_name())); 3523 ik->itable()->dump_itable(); 3524 } 3525 no_old_methods = false; 3526 } 3527 3528 // the constant pool cache should never contain old or obsolete methods 3529 if (ik->constants() != NULL && 3530 ik->constants()->cache() != NULL && 3531 !ik->constants()->cache()->check_no_old_or_obsolete_entries()) { 3532 if (RC_TRACE_ENABLED(0x00004000)) { 3533 RC_TRACE_WITH_THREAD(0x00004000, THREAD, 3534 ("cp-cache::check_no_old_or_obsolete_entries failure" 3535 " -- OLD or OBSOLETE method found -- class: %s", 3536 ik->signature_name())); 3537 ik->constants()->cache()->dump_cache(); 3538 } 3539 no_old_methods = false; 3540 } 3541 3542 if (!no_old_methods) { 3543 if (RC_TRACE_ENABLED(0x00004000)) { 3544 dump_methods(); 3545 } else { 3546 tty->print_cr("INFO: use the '-XX:TraceRedefineClasses=16384' option " 3547 "to see more info about the following guarantee() failure."); 3548 } 3549 guarantee(false, "OLD and/or OBSOLETE method(s) found"); 3550 } 3551 } 3552 } 3553 3554 void VM_RedefineClasses::dump_methods() { 3555 int j; 3556 RC_TRACE(0x00004000, ("_old_methods --")); 3557 for (j = 0; j < _old_methods->length(); ++j) { 3558 Method* m = _old_methods->at(j); 3559 RC_TRACE_NO_CR(0x00004000, ("%4d (%5d) ", j, m->vtable_index())); 3560 m->access_flags().print_on(tty); 3561 tty->print(" -- "); 3562 m->print_name(tty); 3563 tty->cr(); 3564 } 3565 RC_TRACE(0x00004000, ("_new_methods --")); 3566 for (j = 0; j < _new_methods->length(); ++j) { 3567 Method* m = _new_methods->at(j); 3568 RC_TRACE_NO_CR(0x00004000, ("%4d (%5d) ", j, m->vtable_index())); 3569 m->access_flags().print_on(tty); 3570 tty->print(" -- "); 3571 m->print_name(tty); 3572 tty->cr(); 3573 } 3574 RC_TRACE(0x00004000, ("_matching_(old/new)_methods --")); 3575 for (j = 0; j < _matching_methods_length; ++j) { 3576 Method* m = _matching_old_methods[j]; 3577 RC_TRACE_NO_CR(0x00004000, ("%4d (%5d) ", j, m->vtable_index())); 3578 m->access_flags().print_on(tty); 3579 tty->print(" -- "); 3580 m->print_name(tty); 3581 tty->cr(); 3582 m = _matching_new_methods[j]; 3583 RC_TRACE_NO_CR(0x00004000, (" (%5d) ", m->vtable_index())); 3584 m->access_flags().print_on(tty); 3585 tty->cr(); 3586 } 3587 RC_TRACE(0x00004000, ("_deleted_methods --")); 3588 for (j = 0; j < _deleted_methods_length; ++j) { 3589 Method* m = _deleted_methods[j]; 3590 RC_TRACE_NO_CR(0x00004000, ("%4d (%5d) ", j, m->vtable_index())); 3591 m->access_flags().print_on(tty); 3592 tty->print(" -- "); 3593 m->print_name(tty); 3594 tty->cr(); 3595 } 3596 RC_TRACE(0x00004000, ("_added_methods --")); 3597 for (j = 0; j < _added_methods_length; ++j) { 3598 Method* m = _added_methods[j]; 3599 RC_TRACE_NO_CR(0x00004000, ("%4d (%5d) ", j, m->vtable_index())); 3600 m->access_flags().print_on(tty); 3601 tty->print(" -- "); 3602 m->print_name(tty); 3603 tty->cr(); 3604 } 3605 }