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