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