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