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