1 /*
2 * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "cds/aotMetaspace.hpp"
26 #include "cds/cdsConfig.hpp"
27 #include "classfile/classFileStream.hpp"
28 #include "classfile/classLoaderDataGraph.hpp"
29 #include "classfile/classLoadInfo.hpp"
30 #include "classfile/javaClasses.inline.hpp"
31 #include "classfile/klassFactory.hpp"
32 #include "classfile/metadataOnStackMark.hpp"
33 #include "classfile/stackMapTable.hpp"
34 #include "classfile/symbolTable.hpp"
35 #include "classfile/verifier.hpp"
36 #include "classfile/vmClasses.hpp"
37 #include "classfile/vmSymbols.hpp"
38 #include "code/codeCache.hpp"
39 #include "compiler/compileBroker.hpp"
40 #include "interpreter/oopMapCache.hpp"
41 #include "interpreter/rewriter.hpp"
42 #include "jfr/jfrEvents.hpp"
43 #include "logging/logStream.hpp"
44 #include "memory/metadataFactory.hpp"
45 #include "memory/resourceArea.hpp"
46 #include "memory/universe.hpp"
47 #include "oops/annotations.hpp"
48 #include "oops/bsmAttribute.inline.hpp"
49 #include "oops/constantPool.inline.hpp"
50 #include "oops/fieldStreams.inline.hpp"
51 #include "oops/klass.inline.hpp"
52 #include "oops/klassVtable.hpp"
53 #include "oops/method.hpp"
54 #include "oops/oop.inline.hpp"
55 #include "oops/recordComponent.hpp"
56 #include "prims/jvmtiImpl.hpp"
57 #include "prims/jvmtiRedefineClasses.hpp"
58 #include "prims/jvmtiThreadState.inline.hpp"
59 #include "prims/methodComparator.hpp"
60 #include "prims/resolvedMethodTable.hpp"
61 #include "runtime/atomicAccess.hpp"
62 #include "runtime/deoptimization.hpp"
63 #include "runtime/handles.inline.hpp"
64 #include "runtime/jniHandles.inline.hpp"
65 #include "runtime/relocator.hpp"
66 #include "runtime/safepointVerifiers.hpp"
67 #include "utilities/bitMap.inline.hpp"
68 #include "utilities/checkedCast.hpp"
69 #include "utilities/events.hpp"
70 #include "utilities/macros.hpp"
71 #if INCLUDE_JFR
72 #include "jfr/jfr.hpp"
73 #endif
74
75 Array<Method*>* VM_RedefineClasses::_old_methods = nullptr;
76 Array<Method*>* VM_RedefineClasses::_new_methods = nullptr;
77 Method** VM_RedefineClasses::_matching_old_methods = nullptr;
78 Method** VM_RedefineClasses::_matching_new_methods = nullptr;
79 Method** VM_RedefineClasses::_deleted_methods = nullptr;
80 Method** VM_RedefineClasses::_added_methods = nullptr;
81 int VM_RedefineClasses::_matching_methods_length = 0;
82 int VM_RedefineClasses::_deleted_methods_length = 0;
83 int VM_RedefineClasses::_added_methods_length = 0;
84
85 // This flag is global as the constructor does not reset it:
86 bool VM_RedefineClasses::_has_redefined_Object = false;
87 u8 VM_RedefineClasses::_id_counter = 0;
88
89 VM_RedefineClasses::VM_RedefineClasses(jint class_count,
90 const jvmtiClassDefinition *class_defs,
91 JvmtiClassLoadKind class_load_kind) {
92 _class_count = class_count;
93 _class_defs = class_defs;
94 _class_load_kind = class_load_kind;
95 _any_class_has_resolved_methods = false;
96 _res = JVMTI_ERROR_NONE;
97 _the_class = nullptr;
98 _id = next_id();
99 }
100
101 static inline InstanceKlass* get_ik(jclass def) {
102 oop mirror = JNIHandles::resolve_non_null(def);
103 return java_lang_Class::as_InstanceKlass(mirror);
104 }
105
106 // If any of the classes are being redefined, wait
107 // Parallel constant pool merging leads to indeterminate constant pools.
108 void VM_RedefineClasses::lock_classes() {
109 JvmtiThreadState *state = JvmtiThreadState::state_for(JavaThread::current());
110 GrowableArray<Klass*>* redef_classes = state->get_classes_being_redefined();
111
112 MonitorLocker ml(RedefineClasses_lock);
113
114 if (redef_classes == nullptr) {
115 redef_classes = new (mtClass) GrowableArray<Klass*>(1, mtClass);
116 state->set_classes_being_redefined(redef_classes);
117 }
118
119 bool has_redefined;
120 do {
121 has_redefined = false;
122 // Go through classes each time until none are being redefined. Skip
123 // the ones that are being redefined by this thread currently. Class file
124 // load hook event may trigger new class redefine when we are redefining
125 // a class (after lock_classes()).
126 for (int i = 0; i < _class_count; i++) {
127 InstanceKlass* ik = get_ik(_class_defs[i].klass);
128 // Check if we are currently redefining the class in this thread already.
129 if (redef_classes->contains(ik)) {
130 assert(ik->is_being_redefined(), "sanity");
131 } else {
132 if (ik->is_being_redefined()) {
133 ml.wait();
134 has_redefined = true;
135 break; // for loop
136 }
137 }
138 }
139 } while (has_redefined);
140
141 for (int i = 0; i < _class_count; i++) {
142 InstanceKlass* ik = get_ik(_class_defs[i].klass);
143 redef_classes->push(ik); // Add to the _classes_being_redefined list
144 ik->set_is_being_redefined(true);
145 }
146 ml.notify_all();
147 }
148
149 void VM_RedefineClasses::unlock_classes() {
150 JvmtiThreadState *state = JvmtiThreadState::state_for(JavaThread::current());
151 GrowableArray<Klass*>* redef_classes = state->get_classes_being_redefined();
152 assert(redef_classes != nullptr, "_classes_being_redefined is not allocated");
153
154 MonitorLocker ml(RedefineClasses_lock);
155
156 for (int i = _class_count - 1; i >= 0; i--) {
157 InstanceKlass* def_ik = get_ik(_class_defs[i].klass);
158 if (redef_classes->length() > 0) {
159 // Remove the class from _classes_being_redefined list
160 Klass* k = redef_classes->pop();
161 assert(def_ik == k, "unlocking wrong class");
162 }
163 assert(def_ik->is_being_redefined(),
164 "should be being redefined to get here");
165
166 // Unlock after we finish all redefines for this class within
167 // the thread. Same class can be pushed to the list multiple
168 // times (not more than once by each recursive redefinition).
169 if (!redef_classes->contains(def_ik)) {
170 def_ik->set_is_being_redefined(false);
171 }
172 }
173 ml.notify_all();
174 }
175
176 bool VM_RedefineClasses::doit_prologue() {
177 if (_class_count == 0) {
178 _res = JVMTI_ERROR_NONE;
179 return false;
180 }
181 if (_class_defs == nullptr) {
182 _res = JVMTI_ERROR_NULL_POINTER;
183 return false;
184 }
185
186 for (int i = 0; i < _class_count; i++) {
187 if (_class_defs[i].klass == nullptr) {
188 _res = JVMTI_ERROR_INVALID_CLASS;
189 return false;
190 }
191 if (_class_defs[i].class_byte_count == 0) {
192 _res = JVMTI_ERROR_INVALID_CLASS_FORMAT;
193 return false;
194 }
195 if (_class_defs[i].class_bytes == nullptr) {
196 _res = JVMTI_ERROR_NULL_POINTER;
197 return false;
198 }
199
200 oop mirror = JNIHandles::resolve_non_null(_class_defs[i].klass);
201 // classes for primitives, arrays, and hidden classes
202 // cannot be redefined.
203 if (!is_modifiable_class(mirror)) {
204 _res = JVMTI_ERROR_UNMODIFIABLE_CLASS;
205 return false;
206 }
207 }
208
209 // Start timer after all the sanity checks; not quite accurate, but
210 // better than adding a bunch of stop() calls.
211 if (log_is_enabled(Info, redefine, class, timer)) {
212 _timer_vm_op_prologue.start();
213 }
214
215 lock_classes();
216 // We first load new class versions in the prologue, because somewhere down the
217 // call chain it is required that the current thread is a Java thread.
218 _res = load_new_class_versions();
219 if (_res != JVMTI_ERROR_NONE) {
220 // free any successfully created classes, since none are redefined
221 for (int i = 0; i < _class_count; i++) {
222 if (_scratch_classes[i] != nullptr) {
223 ClassLoaderData* cld = _scratch_classes[i]->class_loader_data();
224 // Free the memory for this class at class unloading time. Not before
225 // because CMS might think this is still live.
226 InstanceKlass* ik = get_ik(_class_defs[i].klass);
227 if (ik->get_cached_class_file() == _scratch_classes[i]->get_cached_class_file()) {
228 // Don't double-free cached_class_file copied from the original class if error.
229 _scratch_classes[i]->set_cached_class_file(nullptr);
230 }
231 cld->add_to_deallocate_list(InstanceKlass::cast(_scratch_classes[i]));
232 }
233 }
234 // Free os::malloc allocated memory in load_new_class_version.
235 os::free(_scratch_classes);
236 _timer_vm_op_prologue.stop();
237 unlock_classes();
238 return false;
239 }
240
241 _timer_vm_op_prologue.stop();
242 return true;
243 }
244
245 void VM_RedefineClasses::doit() {
246 Thread* current = Thread::current();
247
248 if (log_is_enabled(Info, redefine, class, timer)) {
249 _timer_vm_op_doit.start();
250 }
251
252 #if INCLUDE_CDS
253 if (CDSConfig::is_using_archive()) {
254 // Sharing is enabled so we remap the shared readonly space to
255 // shared readwrite, private just in case we need to redefine
256 // a shared class. We do the remap during the doit() phase of
257 // the safepoint to be safer.
258 if (!AOTMetaspace::remap_shared_readonly_as_readwrite()) {
259 log_info(redefine, class, load)("failed to remap shared readonly space to readwrite, private");
260 _res = JVMTI_ERROR_INTERNAL;
261 _timer_vm_op_doit.stop();
262 return;
263 }
264 }
265 #endif
266
267 // Mark methods seen on stack and everywhere else so old methods are not
268 // cleaned up if they're on the stack.
269 MetadataOnStackMark md_on_stack(/*walk_all_metadata*/true, /*redefinition_walk*/true);
270 HandleMark hm(current); // make sure any handles created are deleted
271 // before the stack walk again.
272
273 for (int i = 0; i < _class_count; i++) {
274 redefine_single_class(current, _class_defs[i].klass, _scratch_classes[i]);
275 }
276
277 // Flush all compiled code that depends on the classes redefined.
278 flush_dependent_code();
279
280 // Adjust constantpool caches and vtables for all classes
281 // that reference methods of the evolved classes.
282 // Have to do this after all classes are redefined and all methods that
283 // are redefined are marked as old.
284 AdjustAndCleanMetadata adjust_and_clean_metadata(current);
285 ClassLoaderDataGraph::classes_do(&adjust_and_clean_metadata);
286
287 // JSR-292 support
288 if (_any_class_has_resolved_methods) {
289 bool trace_name_printed = false;
290 ResolvedMethodTable::adjust_method_entries(&trace_name_printed);
291 }
292
293 // Increment flag indicating that some invariants are no longer true.
294 // See jvmtiExport.hpp for detailed explanation.
295 JvmtiExport::increment_redefinition_count();
296
297 // check_class() is optionally called for product bits, but is
298 // always called for non-product bits.
299 #ifdef PRODUCT
300 if (log_is_enabled(Trace, redefine, class, obsolete, metadata)) {
301 #endif
302 log_trace(redefine, class, obsolete, metadata)("calling check_class");
303 CheckClass check_class(current);
304 ClassLoaderDataGraph::classes_do(&check_class);
305 #ifdef PRODUCT
306 }
307 #endif
308
309 // Clean up any metadata now unreferenced while MetadataOnStackMark is set.
310 ClassLoaderDataGraph::clean_deallocate_lists(false);
311
312 _timer_vm_op_doit.stop();
313 }
314
315 void VM_RedefineClasses::doit_epilogue() {
316 unlock_classes();
317
318 // Free os::malloc allocated memory.
319 os::free(_scratch_classes);
320
321 // Reset the_class to null for error printing.
322 _the_class = nullptr;
323
324 if (log_is_enabled(Info, redefine, class, timer)) {
325 // Used to have separate timers for "doit" and "all", but the timer
326 // overhead skewed the measurements.
327 julong doit_time = _timer_vm_op_doit.milliseconds();
328 julong all_time = _timer_vm_op_prologue.milliseconds() + doit_time;
329
330 log_info(redefine, class, timer)
331 ("vm_op: all=" JULONG_FORMAT " prologue=" JULONG_FORMAT " doit=" JULONG_FORMAT,
332 all_time, (julong)_timer_vm_op_prologue.milliseconds(), doit_time);
333 log_info(redefine, class, timer)
334 ("redefine_single_class: phase1=" JULONG_FORMAT " phase2=" JULONG_FORMAT,
335 (julong)_timer_rsc_phase1.milliseconds(), (julong)_timer_rsc_phase2.milliseconds());
336 }
337 }
338
339 bool VM_RedefineClasses::is_modifiable_class(oop klass_mirror) {
340 // classes for primitives cannot be redefined
341 if (java_lang_Class::is_primitive(klass_mirror)) {
342 return false;
343 }
344 Klass* k = java_lang_Class::as_Klass(klass_mirror);
345 // classes for arrays cannot be redefined
346 if (k == nullptr || !k->is_instance_klass()) {
347 return false;
348 }
349
350 // Cannot redefine or retransform a hidden class.
351 if (InstanceKlass::cast(k)->is_hidden()) {
352 return false;
353 }
354 if (InstanceKlass::cast(k) == vmClasses::Continuation_klass()) {
355 // Don't redefine Continuation class. See 8302779.
356 return false;
357 }
358 return true;
359 }
360
361 // Append the current entry at scratch_i in scratch_cp to *merge_cp_p
362 // where the end of *merge_cp_p is specified by *merge_cp_length_p. For
363 // direct CP entries, there is just the current entry to append. For
364 // indirect and double-indirect CP entries, there are zero or more
365 // referenced CP entries along with the current entry to append.
366 // Indirect and double-indirect CP entries are handled by recursive
367 // calls to append_entry() as needed. The referenced CP entries are
368 // always appended to *merge_cp_p before the referee CP entry. These
369 // referenced CP entries may already exist in *merge_cp_p in which case
370 // there is nothing extra to append and only the current entry is
371 // appended.
372 void VM_RedefineClasses::append_entry(const constantPoolHandle& scratch_cp,
373 int scratch_i, constantPoolHandle *merge_cp_p, int *merge_cp_length_p) {
374
375 // append is different depending on entry tag type
376 switch (scratch_cp->tag_at(scratch_i).value()) {
377
378 // The old verifier is implemented outside the VM. It loads classes,
379 // but does not resolve constant pool entries directly so we never
380 // see Class entries here with the old verifier. Similarly the old
381 // verifier does not like Class entries in the input constant pool.
382 // The split-verifier is implemented in the VM so it can optionally
383 // and directly resolve constant pool entries to load classes. The
384 // split-verifier can accept either Class entries or UnresolvedClass
385 // entries in the input constant pool. We revert the appended copy
386 // back to UnresolvedClass so that either verifier will be happy
387 // with the constant pool entry.
388 //
389 // this is an indirect CP entry so it needs special handling
390 case JVM_CONSTANT_Class:
391 case JVM_CONSTANT_UnresolvedClass:
392 {
393 int name_i = scratch_cp->klass_name_index_at(scratch_i);
394 int new_name_i = find_or_append_indirect_entry(scratch_cp, name_i, merge_cp_p,
395 merge_cp_length_p);
396
397 if (new_name_i != name_i) {
398 log_trace(redefine, class, constantpool)
399 ("Class entry@%d name_index change: %d to %d",
400 *merge_cp_length_p, name_i, new_name_i);
401 }
402
403 (*merge_cp_p)->temp_unresolved_klass_at_put(*merge_cp_length_p, new_name_i);
404 if (scratch_i != *merge_cp_length_p) {
405 // The new entry in *merge_cp_p is at a different index than
406 // the new entry in scratch_cp so we need to map the index values.
407 map_index(scratch_cp, scratch_i, *merge_cp_length_p);
408 }
409 (*merge_cp_length_p)++;
410 } break;
411
412 // these are direct CP entries so they can be directly appended,
413 // but double and long take two constant pool entries
414 case JVM_CONSTANT_Double: // fall through
415 case JVM_CONSTANT_Long:
416 {
417 ConstantPool::copy_entry_to(scratch_cp, scratch_i, *merge_cp_p, *merge_cp_length_p);
418
419 if (scratch_i != *merge_cp_length_p) {
420 // The new entry in *merge_cp_p is at a different index than
421 // the new entry in scratch_cp so we need to map the index values.
422 map_index(scratch_cp, scratch_i, *merge_cp_length_p);
423 }
424 (*merge_cp_length_p) += 2;
425 } break;
426
427 // these are direct CP entries so they can be directly appended
428 case JVM_CONSTANT_Float: // fall through
429 case JVM_CONSTANT_Integer: // fall through
430 case JVM_CONSTANT_Utf8: // fall through
431
432 // This was an indirect CP entry, but it has been changed into
433 // Symbol*s so this entry can be directly appended.
434 case JVM_CONSTANT_String: // fall through
435 {
436 ConstantPool::copy_entry_to(scratch_cp, scratch_i, *merge_cp_p, *merge_cp_length_p);
437
438 if (scratch_i != *merge_cp_length_p) {
439 // The new entry in *merge_cp_p is at a different index than
440 // the new entry in scratch_cp so we need to map the index values.
441 map_index(scratch_cp, scratch_i, *merge_cp_length_p);
442 }
443 (*merge_cp_length_p)++;
444 } break;
445
446 // this is an indirect CP entry so it needs special handling
447 case JVM_CONSTANT_NameAndType:
448 {
449 int name_ref_i = scratch_cp->name_ref_index_at(scratch_i);
450 int new_name_ref_i = find_or_append_indirect_entry(scratch_cp, name_ref_i, merge_cp_p,
451 merge_cp_length_p);
452
453 int signature_ref_i = scratch_cp->signature_ref_index_at(scratch_i);
454 int new_signature_ref_i = find_or_append_indirect_entry(scratch_cp, signature_ref_i,
455 merge_cp_p, merge_cp_length_p);
456
457 // If the referenced entries already exist in *merge_cp_p, then
458 // both new_name_ref_i and new_signature_ref_i will both be 0.
459 // In that case, all we are appending is the current entry.
460 if (new_name_ref_i != name_ref_i) {
461 log_trace(redefine, class, constantpool)
462 ("NameAndType entry@%d name_ref_index change: %d to %d",
463 *merge_cp_length_p, name_ref_i, new_name_ref_i);
464 }
465 if (new_signature_ref_i != signature_ref_i) {
466 log_trace(redefine, class, constantpool)
467 ("NameAndType entry@%d signature_ref_index change: %d to %d",
468 *merge_cp_length_p, signature_ref_i, new_signature_ref_i);
469 }
470
471 (*merge_cp_p)->name_and_type_at_put(*merge_cp_length_p,
472 new_name_ref_i, new_signature_ref_i);
473 if (scratch_i != *merge_cp_length_p) {
474 // The new entry in *merge_cp_p is at a different index than
475 // the new entry in scratch_cp so we need to map the index values.
476 map_index(scratch_cp, scratch_i, *merge_cp_length_p);
477 }
478 (*merge_cp_length_p)++;
479 } break;
480
481 // this is a double-indirect CP entry so it needs special handling
482 case JVM_CONSTANT_Fieldref: // fall through
483 case JVM_CONSTANT_InterfaceMethodref: // fall through
484 case JVM_CONSTANT_Methodref:
485 {
486 int klass_ref_i = scratch_cp->uncached_klass_ref_index_at(scratch_i);
487 int new_klass_ref_i = find_or_append_indirect_entry(scratch_cp, klass_ref_i,
488 merge_cp_p, merge_cp_length_p);
489
490 int name_and_type_ref_i = scratch_cp->uncached_name_and_type_ref_index_at(scratch_i);
491 int new_name_and_type_ref_i = find_or_append_indirect_entry(scratch_cp, name_and_type_ref_i,
492 merge_cp_p, merge_cp_length_p);
493
494 const char *entry_name = nullptr;
495 switch (scratch_cp->tag_at(scratch_i).value()) {
496 case JVM_CONSTANT_Fieldref:
497 entry_name = "Fieldref";
498 (*merge_cp_p)->field_at_put(*merge_cp_length_p, new_klass_ref_i,
499 new_name_and_type_ref_i);
500 break;
501 case JVM_CONSTANT_InterfaceMethodref:
502 entry_name = "IFMethodref";
503 (*merge_cp_p)->interface_method_at_put(*merge_cp_length_p,
504 new_klass_ref_i, new_name_and_type_ref_i);
505 break;
506 case JVM_CONSTANT_Methodref:
507 entry_name = "Methodref";
508 (*merge_cp_p)->method_at_put(*merge_cp_length_p, new_klass_ref_i,
509 new_name_and_type_ref_i);
510 break;
511 default:
512 guarantee(false, "bad switch");
513 break;
514 }
515
516 if (klass_ref_i != new_klass_ref_i) {
517 log_trace(redefine, class, constantpool)
518 ("%s entry@%d class_index changed: %d to %d", entry_name, *merge_cp_length_p, klass_ref_i, new_klass_ref_i);
519 }
520 if (name_and_type_ref_i != new_name_and_type_ref_i) {
521 log_trace(redefine, class, constantpool)
522 ("%s entry@%d name_and_type_index changed: %d to %d",
523 entry_name, *merge_cp_length_p, name_and_type_ref_i, new_name_and_type_ref_i);
524 }
525
526 if (scratch_i != *merge_cp_length_p) {
527 // The new entry in *merge_cp_p is at a different index than
528 // the new entry in scratch_cp so we need to map the index values.
529 map_index(scratch_cp, scratch_i, *merge_cp_length_p);
530 }
531 (*merge_cp_length_p)++;
532 } break;
533
534 // this is an indirect CP entry so it needs special handling
535 case JVM_CONSTANT_MethodType:
536 {
537 int ref_i = scratch_cp->method_type_index_at(scratch_i);
538 int new_ref_i = find_or_append_indirect_entry(scratch_cp, ref_i, merge_cp_p,
539 merge_cp_length_p);
540 if (new_ref_i != ref_i) {
541 log_trace(redefine, class, constantpool)
542 ("MethodType entry@%d ref_index change: %d to %d", *merge_cp_length_p, ref_i, new_ref_i);
543 }
544 (*merge_cp_p)->method_type_index_at_put(*merge_cp_length_p, new_ref_i);
545 if (scratch_i != *merge_cp_length_p) {
546 // The new entry in *merge_cp_p is at a different index than
547 // the new entry in scratch_cp so we need to map the index values.
548 map_index(scratch_cp, scratch_i, *merge_cp_length_p);
549 }
550 (*merge_cp_length_p)++;
551 } break;
552
553 // this is an indirect CP entry so it needs special handling
554 case JVM_CONSTANT_MethodHandle:
555 {
556 int ref_kind = scratch_cp->method_handle_ref_kind_at(scratch_i);
557 int ref_i = scratch_cp->method_handle_index_at(scratch_i);
558 int new_ref_i = find_or_append_indirect_entry(scratch_cp, ref_i, merge_cp_p,
559 merge_cp_length_p);
560 if (new_ref_i != ref_i) {
561 log_trace(redefine, class, constantpool)
562 ("MethodHandle entry@%d ref_index change: %d to %d", *merge_cp_length_p, ref_i, new_ref_i);
563 }
564 (*merge_cp_p)->method_handle_index_at_put(*merge_cp_length_p, ref_kind, new_ref_i);
565 if (scratch_i != *merge_cp_length_p) {
566 // The new entry in *merge_cp_p is at a different index than
567 // the new entry in scratch_cp so we need to map the index values.
568 map_index(scratch_cp, scratch_i, *merge_cp_length_p);
569 }
570 (*merge_cp_length_p)++;
571 } break;
572
573 // this is an indirect CP entry so it needs special handling
574 case JVM_CONSTANT_Dynamic: // fall through
575 case JVM_CONSTANT_InvokeDynamic:
576 {
577 // Index of the bootstrap specifier in the BSM array
578 int old_bs_i = scratch_cp->bootstrap_methods_attribute_index(scratch_i);
579 int new_bs_i = find_or_append_bsm_entry(scratch_cp, old_bs_i, merge_cp_p,
580 merge_cp_length_p);
581 // The bootstrap method NameAndType_info index
582 int old_ref_i = scratch_cp->bootstrap_name_and_type_ref_index_at(scratch_i);
583 int new_ref_i = find_or_append_indirect_entry(scratch_cp, old_ref_i, merge_cp_p,
584 merge_cp_length_p);
585 if (new_bs_i != old_bs_i) {
586 log_trace(redefine, class, constantpool)
587 ("Dynamic entry@%d bootstrap_method_attr_index change: %d to %d",
588 *merge_cp_length_p, old_bs_i, new_bs_i);
589 }
590 if (new_ref_i != old_ref_i) {
591 log_trace(redefine, class, constantpool)
592 ("Dynamic entry@%d name_and_type_index change: %d to %d", *merge_cp_length_p, old_ref_i, new_ref_i);
593 }
594
595 if (scratch_cp->tag_at(scratch_i).is_dynamic_constant()) {
596 (*merge_cp_p)->dynamic_constant_at_put(*merge_cp_length_p, new_bs_i, new_ref_i);
597 } else {
598 (*merge_cp_p)->invoke_dynamic_at_put(*merge_cp_length_p, new_bs_i, new_ref_i);
599 }
600 if (scratch_i != *merge_cp_length_p) {
601 // The new entry in *merge_cp_p is at a different index than
602 // the new entry in scratch_cp so we need to map the index values.
603 map_index(scratch_cp, scratch_i, *merge_cp_length_p);
604 }
605 (*merge_cp_length_p)++;
606 } break;
607
608 // At this stage, Class or UnresolvedClass could be in scratch_cp, but not
609 // ClassIndex
610 case JVM_CONSTANT_ClassIndex: // fall through
611
612 // Invalid is used as the tag for the second constant pool entry
613 // occupied by JVM_CONSTANT_Double or JVM_CONSTANT_Long. It should
614 // not be seen by itself.
615 case JVM_CONSTANT_Invalid: // fall through
616
617 // At this stage, String could be here, but not StringIndex
618 case JVM_CONSTANT_StringIndex: // fall through
619
620 // At this stage JVM_CONSTANT_UnresolvedClassInError should not be here
621 case JVM_CONSTANT_UnresolvedClassInError: // fall through
622
623 default:
624 {
625 // leave a breadcrumb
626 jbyte bad_value = scratch_cp->tag_at(scratch_i).value();
627 ShouldNotReachHere();
628 } break;
629 } // end switch tag value
630 } // end append_entry()
631
632
633 u2 VM_RedefineClasses::find_or_append_indirect_entry(const constantPoolHandle& scratch_cp,
634 int ref_i, constantPoolHandle *merge_cp_p, int *merge_cp_length_p) {
635
636 int new_ref_i = ref_i;
637 bool match = (ref_i < *merge_cp_length_p) &&
638 scratch_cp->compare_entry_to(ref_i, *merge_cp_p, ref_i);
639
640 if (!match) {
641 // forward reference in *merge_cp_p or not a direct match
642 int found_i = scratch_cp->find_matching_entry(ref_i, *merge_cp_p);
643 if (found_i != 0) {
644 guarantee(found_i != ref_i, "compare_entry_to() and find_matching_entry() do not agree");
645 // Found a matching entry somewhere else in *merge_cp_p so just need a mapping entry.
646 new_ref_i = found_i;
647 map_index(scratch_cp, ref_i, found_i);
648 } else {
649 // no match found so we have to append this entry to *merge_cp_p
650 append_entry(scratch_cp, ref_i, merge_cp_p, merge_cp_length_p);
651 // The above call to append_entry() can only append one entry
652 // so the post call query of *merge_cp_length_p is only for
653 // the sake of consistency.
654 new_ref_i = *merge_cp_length_p - 1;
655 }
656 }
657
658 // constant pool indices are u2, unless the merged constant pool overflows which
659 // we don't check for.
660 return checked_cast<u2>(new_ref_i);
661 } // end find_or_append_indirect_entry()
662
663
664 // Append a bootstrap specifier into the merge_cp BSM entries that is semantically equal
665 // to the scratch_cp BSM entries' bootstrap specifier passed by the old_bs_i index.
666 // Recursively append new merge_cp entries referenced by the new bootstrap specifier.
667 int VM_RedefineClasses::append_bsm_entry(const constantPoolHandle& scratch_cp, const int old_bs_i,
668 constantPoolHandle *merge_cp_p, int *merge_cp_length_p) {
669
670 BSMAttributeEntry* old_bsme = scratch_cp->bsm_attribute_entry(old_bs_i);
671 u2 old_ref_i = old_bsme->bootstrap_method_index();
672 u2 new_ref_i = find_or_append_indirect_entry(scratch_cp, old_ref_i, merge_cp_p,
673 merge_cp_length_p);
674 if (new_ref_i != old_ref_i) {
675 log_trace(redefine, class, constantpool)
676 ("BSM attribute entry@%d bootstrap method ref_index change: %d to %d", _bsmae_iter.current_offset() - 1, old_ref_i, new_ref_i);
677 }
678
679 const int new_bs_i = _bsmae_iter.current_offset();
680 BSMAttributeEntry* new_bsme =
681 _bsmae_iter.reserve_new_entry(new_ref_i, old_bsme->argument_count());
682 assert(new_bsme != nullptr, "must be");
683 for (int i = 0; i < new_bsme->argument_count(); i++) {
684 u2 old_arg_ref_i = old_bsme->argument(i);
685 u2 new_arg_ref_i = find_or_append_indirect_entry(scratch_cp, old_arg_ref_i, merge_cp_p,
686 merge_cp_length_p);
687 new_bsme->set_argument(i, new_arg_ref_i);
688
689 if (new_arg_ref_i != old_arg_ref_i) {
690 log_trace(redefine, class, constantpool)
691 ("BSM attribute entry@%d bootstrap method argument ref_index change: %d to %d",
692 _bsmae_iter.current_offset() - 1, old_arg_ref_i, new_arg_ref_i);
693 }
694 }
695 // This is only for the logging
696 map_bsm_index(old_bs_i, new_bs_i);
697 return new_bs_i;
698 } // end append_bsm_entry()
699
700
701 int VM_RedefineClasses::find_or_append_bsm_entry(const constantPoolHandle& scratch_cp,
702 int old_bs_i, constantPoolHandle *merge_cp_p, int *merge_cp_length_p) {
703
704 const int max_offset_in_merge = _bsmae_iter.current_offset();
705 int new_bs_i = old_bs_i; // bootstrap specifier index
706 // Has the old_bs_i index been used already? Check if it's the same so we know
707 // whether or not a remapping is required.
708 bool match = (old_bs_i < max_offset_in_merge) &&
709 scratch_cp->compare_bootstrap_entry_to(old_bs_i, *merge_cp_p, old_bs_i);
710
711 if (!match) {
712 // forward reference in *merge_cp_p or not a direct match
713 int found_i = scratch_cp->find_matching_bsm_entry(old_bs_i, *merge_cp_p,
714 max_offset_in_merge);
715 if (found_i != -1) {
716 guarantee(found_i != old_bs_i, "compare_bootstrap_entry_to() and find_matching_bsm_entry() disagree");
717 // found a matching BSM entry somewhere else in *merge_cp_p so just need a mapping
718 new_bs_i = found_i;
719 map_bsm_index(old_bs_i, found_i);
720 } else {
721 // no match found so we have to append this bootstrap specifier to *merge_cp_p
722 new_bs_i = append_bsm_entry(scratch_cp, old_bs_i, merge_cp_p, merge_cp_length_p);
723 }
724 }
725 return new_bs_i;
726 } // end find_or_append_bsm_entry()
727
728
729 void VM_RedefineClasses::finalize_bsm_entries_merge(const constantPoolHandle& merge_cp, TRAPS) {
730 if (merge_cp->bsm_entries().number_of_entries() == 0) {
731 return;
732 }
733 // Finished extending the BSMAEs
734 merge_cp->end_extension(_bsmae_iter, CHECK);
735
736 if (log_is_enabled(Trace, redefine, class, constantpool)) {
737 // don't want to loop unless we are tracing
738 int count = 0;
739 for (int i = 1; i < _bsm_index_map_p->length(); i++) {
740 int value = _bsm_index_map_p->at(i);
741 if (value != -1) {
742 log_trace(redefine, class, constantpool)("bsm_index_map[%d]: old=%d new=%d", count, i, value);
743 count++;
744 }
745 }
746 }
747 // Clean-up
748 _bsm_index_map_p = nullptr;
749 _bsm_index_map_count = 0;
750 _bsmae_iter = BSMAttributeEntries::InsertionIterator();
751 } // end finalize_bsmentries_merge()
752
753 // Symbol* comparator for qsort
754 // The caller must have an active ResourceMark.
755 static int symcmp(const void* a, const void* b) {
756 char* astr = (*(Symbol**)a)->as_C_string();
757 char* bstr = (*(Symbol**)b)->as_C_string();
758 return strcmp(astr, bstr);
759 }
760
761 // The caller must have an active ResourceMark.
762 static jvmtiError check_attribute_arrays(const char* attr_name,
763 InstanceKlass* the_class, InstanceKlass* scratch_class,
764 Array<u2>* the_array, Array<u2>* scr_array) {
765 bool the_array_exists = the_array != Universe::the_empty_short_array();
766 bool scr_array_exists = scr_array != Universe::the_empty_short_array();
767
768 int array_len = the_array->length();
769 if (the_array_exists && scr_array_exists) {
770 if (array_len != scr_array->length()) {
771 log_trace(redefine, class)
772 ("redefined class %s attribute change error: %s len=%d changed to len=%d",
773 the_class->external_name(), attr_name, array_len, scr_array->length());
774 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_ATTRIBUTE_CHANGED;
775 }
776
777 // The order of entries in the attribute array is not specified so we
778 // have to explicitly check for the same contents. We do this by copying
779 // the referenced symbols into their own arrays, sorting them and then
780 // comparing each element pair.
781
782 Symbol** the_syms = NEW_RESOURCE_ARRAY_RETURN_NULL(Symbol*, array_len);
783 Symbol** scr_syms = NEW_RESOURCE_ARRAY_RETURN_NULL(Symbol*, array_len);
784
785 if (the_syms == nullptr || scr_syms == nullptr) {
786 return JVMTI_ERROR_OUT_OF_MEMORY;
787 }
788
789 for (int i = 0; i < array_len; i++) {
790 int the_cp_index = the_array->at(i);
791 int scr_cp_index = scr_array->at(i);
792 the_syms[i] = the_class->constants()->klass_name_at(the_cp_index);
793 scr_syms[i] = scratch_class->constants()->klass_name_at(scr_cp_index);
794 }
795
796 qsort(the_syms, array_len, sizeof(Symbol*), symcmp);
797 qsort(scr_syms, array_len, sizeof(Symbol*), symcmp);
798
799 for (int i = 0; i < array_len; i++) {
800 if (the_syms[i] != scr_syms[i]) {
801 log_info(redefine, class)
802 ("redefined class %s attribute change error: %s[%d]: %s changed to %s",
803 the_class->external_name(), attr_name, i,
804 the_syms[i]->as_C_string(), scr_syms[i]->as_C_string());
805 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_ATTRIBUTE_CHANGED;
806 }
807 }
808 } else if (the_array_exists ^ scr_array_exists) {
809 const char* action_str = (the_array_exists) ? "removed" : "added";
810 log_info(redefine, class)
811 ("redefined class %s attribute change error: %s attribute %s",
812 the_class->external_name(), attr_name, action_str);
813 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_ATTRIBUTE_CHANGED;
814 }
815 return JVMTI_ERROR_NONE;
816 }
817
818 static jvmtiError check_nest_attributes(InstanceKlass* the_class,
819 InstanceKlass* scratch_class) {
820 // Check whether the class NestHost attribute has been changed.
821 Thread* thread = Thread::current();
822 ResourceMark rm(thread);
823 u2 the_nest_host_idx = the_class->nest_host_index();
824 u2 scr_nest_host_idx = scratch_class->nest_host_index();
825
826 if (the_nest_host_idx != 0 && scr_nest_host_idx != 0) {
827 Symbol* the_sym = the_class->constants()->klass_name_at(the_nest_host_idx);
828 Symbol* scr_sym = scratch_class->constants()->klass_name_at(scr_nest_host_idx);
829 if (the_sym != scr_sym) {
830 log_info(redefine, class, nestmates)
831 ("redefined class %s attribute change error: NestHost class: %s replaced with: %s",
832 the_class->external_name(), the_sym->as_C_string(), scr_sym->as_C_string());
833 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_ATTRIBUTE_CHANGED;
834 }
835 } else if ((the_nest_host_idx == 0) ^ (scr_nest_host_idx == 0)) {
836 const char* action_str = (the_nest_host_idx != 0) ? "removed" : "added";
837 log_info(redefine, class, nestmates)
838 ("redefined class %s attribute change error: NestHost attribute %s",
839 the_class->external_name(), action_str);
840 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_ATTRIBUTE_CHANGED;
841 }
842
843 // Check whether the class NestMembers attribute has been changed.
844 return check_attribute_arrays("NestMembers",
845 the_class, scratch_class,
846 the_class->nest_members(),
847 scratch_class->nest_members());
848 }
849
850 // Return an error status if the class Record attribute was changed.
851 static jvmtiError check_record_attribute(InstanceKlass* the_class, InstanceKlass* scratch_class) {
852 // Get lists of record components.
853 Array<RecordComponent*>* the_record = the_class->record_components();
854 Array<RecordComponent*>* scr_record = scratch_class->record_components();
855 bool the_record_exists = the_record != nullptr;
856 bool scr_record_exists = scr_record != nullptr;
857
858 if (the_record_exists && scr_record_exists) {
859 int the_num_components = the_record->length();
860 int scr_num_components = scr_record->length();
861 if (the_num_components != scr_num_components) {
862 log_info(redefine, class, record)
863 ("redefined class %s attribute change error: Record num_components=%d changed to num_components=%d",
864 the_class->external_name(), the_num_components, scr_num_components);
865 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_ATTRIBUTE_CHANGED;
866 }
867
868 // Compare each field in each record component.
869 ConstantPool* the_cp = the_class->constants();
870 ConstantPool* scr_cp = scratch_class->constants();
871 for (int x = 0; x < the_num_components; x++) {
872 RecordComponent* the_component = the_record->at(x);
873 RecordComponent* scr_component = scr_record->at(x);
874 const Symbol* const the_name = the_cp->symbol_at(the_component->name_index());
875 const Symbol* const scr_name = scr_cp->symbol_at(scr_component->name_index());
876 const Symbol* const the_descr = the_cp->symbol_at(the_component->descriptor_index());
877 const Symbol* const scr_descr = scr_cp->symbol_at(scr_component->descriptor_index());
878 if (the_name != scr_name || the_descr != scr_descr) {
879 log_info(redefine, class, record)
880 ("redefined class %s attribute change error: Record name_index, descriptor_index, and/or attributes_count changed",
881 the_class->external_name());
882 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_ATTRIBUTE_CHANGED;
883 }
884
885 int the_gen_sig = the_component->generic_signature_index();
886 int scr_gen_sig = scr_component->generic_signature_index();
887 const Symbol* const the_gen_sig_sym = (the_gen_sig == 0 ? nullptr :
888 the_cp->symbol_at(the_component->generic_signature_index()));
889 const Symbol* const scr_gen_sig_sym = (scr_gen_sig == 0 ? nullptr :
890 scr_cp->symbol_at(scr_component->generic_signature_index()));
891 if (the_gen_sig_sym != scr_gen_sig_sym) {
892 log_info(redefine, class, record)
893 ("redefined class %s attribute change error: Record generic_signature attribute changed",
894 the_class->external_name());
895 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_ATTRIBUTE_CHANGED;
896 }
897
898 // It's okay if a record component's annotations were changed.
899 }
900
901 } else if (the_record_exists ^ scr_record_exists) {
902 const char* action_str = (the_record_exists) ? "removed" : "added";
903 log_info(redefine, class, record)
904 ("redefined class %s attribute change error: Record attribute %s",
905 the_class->external_name(), action_str);
906 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_ATTRIBUTE_CHANGED;
907 }
908
909 return JVMTI_ERROR_NONE;
910 }
911
912
913 static jvmtiError check_permitted_subclasses_attribute(InstanceKlass* the_class,
914 InstanceKlass* scratch_class) {
915 Thread* thread = Thread::current();
916 ResourceMark rm(thread);
917
918 // Check whether the class PermittedSubclasses attribute has been changed.
919 return check_attribute_arrays("PermittedSubclasses",
920 the_class, scratch_class,
921 the_class->permitted_subclasses(),
922 scratch_class->permitted_subclasses());
923 }
924
925 static bool can_add_or_delete(Method* m) {
926 // Compatibility mode
927 return (AllowRedefinitionToAddDeleteMethods &&
928 (m->is_private() && (m->is_static() || m->is_final())));
929 }
930
931 jvmtiError VM_RedefineClasses::compare_and_normalize_class_versions(
932 InstanceKlass* the_class,
933 InstanceKlass* scratch_class) {
934 int i;
935
936 // Check superclasses, or rather their names, since superclasses themselves can be
937 // requested to replace.
938 // Check for null superclass first since this might be java.lang.Object
939 if (the_class->super() != scratch_class->super() &&
940 (the_class->super() == nullptr || scratch_class->super() == nullptr ||
941 the_class->super()->name() !=
942 scratch_class->super()->name())) {
943 log_info(redefine, class, normalize)
944 ("redefined class %s superclass change error: superclass changed from %s to %s.",
945 the_class->external_name(),
946 the_class->super() == nullptr ? "null" : the_class->super()->external_name(),
947 scratch_class->super() == nullptr ? "null" : scratch_class->super()->external_name());
948 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED;
949 }
950
951 // Check if the number, names and order of directly implemented interfaces are the same.
952 // I think in principle we should just check if the sets of names of directly implemented
953 // interfaces are the same, i.e. the order of declaration (which, however, if changed in the
954 // .java file, also changes in .class file) should not matter. However, comparing sets is
955 // technically a bit more difficult, and, more importantly, I am not sure at present that the
956 // order of interfaces does not matter on the implementation level, i.e. that the VM does not
957 // rely on it somewhere.
958 Array<InstanceKlass*>* k_interfaces = the_class->local_interfaces();
959 Array<InstanceKlass*>* k_new_interfaces = scratch_class->local_interfaces();
960 int n_intfs = k_interfaces->length();
961 if (n_intfs != k_new_interfaces->length()) {
962 log_info(redefine, class, normalize)
963 ("redefined class %s interfaces change error: number of implemented interfaces changed from %d to %d.",
964 the_class->external_name(), n_intfs, k_new_interfaces->length());
965 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED;
966 }
967 for (i = 0; i < n_intfs; i++) {
968 if (k_interfaces->at(i)->name() !=
969 k_new_interfaces->at(i)->name()) {
970 log_info(redefine, class, normalize)
971 ("redefined class %s interfaces change error: interface changed from %s to %s.",
972 the_class->external_name(),
973 k_interfaces->at(i)->external_name(), k_new_interfaces->at(i)->external_name());
974 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED;
975 }
976 }
977
978 // Check whether class is in the error init state.
979 if (the_class->is_in_error_state()) {
980 log_info(redefine, class, normalize)
981 ("redefined class %s is in error init state.", the_class->external_name());
982 // TBD #5057930: special error code is needed in 1.6
983 return JVMTI_ERROR_INVALID_CLASS;
984 }
985
986 // Check whether the nest-related attributes have been changed.
987 jvmtiError err = check_nest_attributes(the_class, scratch_class);
988 if (err != JVMTI_ERROR_NONE) {
989 return err;
990 }
991
992 // Check whether the Record attribute has been changed.
993 err = check_record_attribute(the_class, scratch_class);
994 if (err != JVMTI_ERROR_NONE) {
995 return err;
996 }
997
998 // Check whether the PermittedSubclasses attribute has been changed.
999 err = check_permitted_subclasses_attribute(the_class, scratch_class);
1000 if (err != JVMTI_ERROR_NONE) {
1001 return err;
1002 }
1003
1004 // Check whether class modifiers are the same.
1005 u2 old_flags = the_class->access_flags().as_class_flags();
1006 u2 new_flags = scratch_class->access_flags().as_class_flags();
1007 if (old_flags != new_flags) {
1008 log_info(redefine, class, normalize)
1009 ("redefined class %s modifiers change error: modifiers changed from %d to %d.",
1010 the_class->external_name(), old_flags, new_flags);
1011 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED;
1012 }
1013
1014 // Check if the number, names, types and order of fields declared in these classes
1015 // are the same.
1016 JavaFieldStream old_fs(the_class);
1017 JavaFieldStream new_fs(scratch_class);
1018 for (; !old_fs.done() && !new_fs.done(); old_fs.next(), new_fs.next()) {
1019 // name and signature
1020 Symbol* name_sym1 = the_class->constants()->symbol_at(old_fs.name_index());
1021 Symbol* sig_sym1 = the_class->constants()->symbol_at(old_fs.signature_index());
1022 Symbol* name_sym2 = scratch_class->constants()->symbol_at(new_fs.name_index());
1023 Symbol* sig_sym2 = scratch_class->constants()->symbol_at(new_fs.signature_index());
1024 if (name_sym1 != name_sym2 || sig_sym1 != sig_sym2) {
1025 log_info(redefine, class, normalize)
1026 ("redefined class %s fields change error: field %s %s changed to %s %s.",
1027 the_class->external_name(),
1028 sig_sym1->as_C_string(), name_sym1->as_C_string(),
1029 sig_sym2->as_C_string(), name_sym2->as_C_string());
1030 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED;
1031 }
1032 // offset
1033 if (old_fs.offset() != new_fs.offset()) {
1034 log_info(redefine, class, normalize)
1035 ("redefined class %s field %s change error: offset changed from %d to %d.",
1036 the_class->external_name(), name_sym2->as_C_string(), old_fs.offset(), new_fs.offset());
1037 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED;
1038 }
1039 // access
1040 old_flags = old_fs.access_flags().as_field_flags();
1041 new_flags = new_fs.access_flags().as_field_flags();
1042 if (old_flags != new_flags) {
1043 log_info(redefine, class, normalize)
1044 ("redefined class %s field %s change error: modifiers changed from %d to %d.",
1045 the_class->external_name(), name_sym2->as_C_string(), old_flags, new_flags);
1046 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED;
1047 }
1048 }
1049
1050 // If both streams aren't done then we have a differing number of
1051 // fields.
1052 if (!old_fs.done() || !new_fs.done()) {
1053 const char* action = old_fs.done() ? "added" : "deleted";
1054 log_info(redefine, class, normalize)
1055 ("redefined class %s fields change error: some fields were %s.",
1056 the_class->external_name(), action);
1057 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED;
1058 }
1059
1060 // Do a parallel walk through the old and new methods. Detect
1061 // cases where they match (exist in both), have been added in
1062 // the new methods, or have been deleted (exist only in the
1063 // old methods). The class file parser places methods in order
1064 // by method name, but does not order overloaded methods by
1065 // signature. In order to determine what fate befell the methods,
1066 // this code places the overloaded new methods that have matching
1067 // old methods in the same order as the old methods and places
1068 // new overloaded methods at the end of overloaded methods of
1069 // that name. The code for this order normalization is adapted
1070 // from the algorithm used in InstanceKlass::find_method().
1071 // Since we are swapping out of order entries as we find them,
1072 // we only have to search forward through the overloaded methods.
1073 // Methods which are added and have the same name as an existing
1074 // method (but different signature) will be put at the end of
1075 // the methods with that name, and the name mismatch code will
1076 // handle them.
1077 Array<Method*>* k_old_methods(the_class->methods());
1078 Array<Method*>* k_new_methods(scratch_class->methods());
1079 int n_old_methods = k_old_methods->length();
1080 int n_new_methods = k_new_methods->length();
1081 Thread* thread = Thread::current();
1082
1083 int ni = 0;
1084 int oi = 0;
1085 while (true) {
1086 Method* k_old_method;
1087 Method* k_new_method;
1088 enum { matched, added, deleted, undetermined } method_was = undetermined;
1089
1090 if (oi >= n_old_methods) {
1091 if (ni >= n_new_methods) {
1092 break; // we've looked at everything, done
1093 }
1094 // New method at the end
1095 k_new_method = k_new_methods->at(ni);
1096 method_was = added;
1097 } else if (ni >= n_new_methods) {
1098 // Old method, at the end, is deleted
1099 k_old_method = k_old_methods->at(oi);
1100 method_was = deleted;
1101 } else {
1102 // There are more methods in both the old and new lists
1103 k_old_method = k_old_methods->at(oi);
1104 k_new_method = k_new_methods->at(ni);
1105 if (k_old_method->name() != k_new_method->name()) {
1106 // Methods are sorted by method name, so a mismatch means added
1107 // or deleted
1108 if (k_old_method->name()->fast_compare(k_new_method->name()) > 0) {
1109 method_was = added;
1110 } else {
1111 method_was = deleted;
1112 }
1113 } else if (k_old_method->signature() == k_new_method->signature()) {
1114 // Both the name and signature match
1115 method_was = matched;
1116 } else {
1117 // The name matches, but the signature doesn't, which means we have to
1118 // search forward through the new overloaded methods.
1119 int nj; // outside the loop for post-loop check
1120 for (nj = ni + 1; nj < n_new_methods; nj++) {
1121 Method* m = k_new_methods->at(nj);
1122 if (k_old_method->name() != m->name()) {
1123 // reached another method name so no more overloaded methods
1124 method_was = deleted;
1125 break;
1126 }
1127 if (k_old_method->signature() == m->signature()) {
1128 // found a match so swap the methods
1129 k_new_methods->at_put(ni, m);
1130 k_new_methods->at_put(nj, k_new_method);
1131 k_new_method = m;
1132 method_was = matched;
1133 break;
1134 }
1135 }
1136
1137 if (nj >= n_new_methods) {
1138 // reached the end without a match; so method was deleted
1139 method_was = deleted;
1140 }
1141 }
1142 }
1143
1144 switch (method_was) {
1145 case matched:
1146 // methods match, be sure modifiers do too
1147 old_flags = k_old_method->access_flags().as_method_flags();
1148 new_flags = k_new_method->access_flags().as_method_flags();
1149 if ((old_flags ^ new_flags) & ~(JVM_ACC_NATIVE)) {
1150 log_info(redefine, class, normalize)
1151 ("redefined class %s method %s modifiers error: modifiers changed from %d to %d",
1152 the_class->external_name(), k_old_method->name_and_sig_as_C_string(), old_flags, new_flags);
1153 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED;
1154 }
1155 {
1156 u2 new_num = k_new_method->method_idnum();
1157 u2 old_num = k_old_method->method_idnum();
1158 if (new_num != old_num) {
1159 Method* idnum_owner = scratch_class->method_with_idnum(old_num);
1160 if (idnum_owner != nullptr) {
1161 // There is already a method assigned this idnum -- switch them
1162 // Take current and original idnum from the new_method
1163 idnum_owner->set_method_idnum(new_num);
1164 idnum_owner->set_orig_method_idnum(k_new_method->orig_method_idnum());
1165 }
1166 // Take current and original idnum from the old_method
1167 k_new_method->set_method_idnum(old_num);
1168 k_new_method->set_orig_method_idnum(k_old_method->orig_method_idnum());
1169 if (thread->has_pending_exception()) {
1170 return JVMTI_ERROR_OUT_OF_MEMORY;
1171 }
1172 }
1173 }
1174 log_trace(redefine, class, normalize)
1175 ("Method matched: new: %s [%d] == old: %s [%d]",
1176 k_new_method->name_and_sig_as_C_string(), ni, k_old_method->name_and_sig_as_C_string(), oi);
1177 // advance to next pair of methods
1178 ++oi;
1179 ++ni;
1180 break;
1181 case added:
1182 // method added, see if it is OK
1183 if (!can_add_or_delete(k_new_method)) {
1184 log_info(redefine, class, normalize)
1185 ("redefined class %s methods error: added method: %s [%d]",
1186 the_class->external_name(), k_new_method->name_and_sig_as_C_string(), ni);
1187 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED;
1188 }
1189 {
1190 u2 num = the_class->next_method_idnum();
1191 if (num == ConstMethod::UNSET_IDNUM) {
1192 // cannot add any more methods
1193 log_info(redefine, class, normalize)
1194 ("redefined class %s methods error: can't create ID for new method %s [%d]",
1195 the_class->external_name(), k_new_method->name_and_sig_as_C_string(), ni);
1196 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED;
1197 }
1198 u2 new_num = k_new_method->method_idnum();
1199 Method* idnum_owner = scratch_class->method_with_idnum(num);
1200 if (idnum_owner != nullptr) {
1201 // There is already a method assigned this idnum -- switch them
1202 // Take current and original idnum from the new_method
1203 idnum_owner->set_method_idnum(new_num);
1204 idnum_owner->set_orig_method_idnum(k_new_method->orig_method_idnum());
1205 }
1206 k_new_method->set_method_idnum(num);
1207 k_new_method->set_orig_method_idnum(num);
1208 if (thread->has_pending_exception()) {
1209 return JVMTI_ERROR_OUT_OF_MEMORY;
1210 }
1211 }
1212 log_trace(redefine, class, normalize)
1213 ("Method added: new: %s [%d]", k_new_method->name_and_sig_as_C_string(), ni);
1214 ++ni; // advance to next new method
1215 break;
1216 case deleted:
1217 // method deleted, see if it is OK
1218 if (!can_add_or_delete(k_old_method)) {
1219 log_info(redefine, class, normalize)
1220 ("redefined class %s methods error: deleted method %s [%d]",
1221 the_class->external_name(), k_old_method->name_and_sig_as_C_string(), oi);
1222 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED;
1223 }
1224 log_trace(redefine, class, normalize)
1225 ("Method deleted: old: %s [%d]", k_old_method->name_and_sig_as_C_string(), oi);
1226 ++oi; // advance to next old method
1227 break;
1228 default:
1229 ShouldNotReachHere();
1230 }
1231 }
1232
1233 return JVMTI_ERROR_NONE;
1234 }
1235
1236
1237 // Find new constant pool index value for old constant pool index value
1238 // by searching the index map. Returns zero (0) if there is no mapped
1239 // value for the old constant pool index.
1240 u2 VM_RedefineClasses::find_new_index(int old_index) {
1241 if (_index_map_count == 0) {
1242 // map is empty so nothing can be found
1243 return 0;
1244 }
1245
1246 if (old_index < 1 || old_index >= _index_map_p->length()) {
1247 // The old_index is out of range so it is not mapped. This should
1248 // not happen in regular constant pool merging use, but it can
1249 // happen if a corrupt annotation is processed.
1250 return 0;
1251 }
1252
1253 int value = _index_map_p->at(old_index);
1254 if (value == -1) {
1255 // the old_index is not mapped
1256 return 0;
1257 }
1258
1259 // constant pool indices are u2, unless the merged constant pool overflows which
1260 // we don't check for.
1261 return checked_cast<u2>(value);
1262 } // end find_new_index()
1263
1264
1265 // Find new bootstrap specifier index value for old bootstrap specifier index
1266 // value by searching the index map. Returns unused index (-1) if there is
1267 // no mapped value for the old bootstrap specifier index.
1268 int VM_RedefineClasses::find_new_bsm_index(int old_index) {
1269 if (_bsm_index_map_count == 0) {
1270 // map is empty so nothing can be found
1271 return -1;
1272 }
1273
1274 if (old_index == -1 || old_index >= _bsm_index_map_p->length()) {
1275 // The old_index is out of range so it is not mapped.
1276 // This should not happen in regular constant pool merging use.
1277 return -1;
1278 }
1279
1280 int value = _bsm_index_map_p->at(old_index);
1281 if (value == -1) {
1282 // the old_index is not mapped
1283 return -1;
1284 }
1285
1286 return value;
1287 } // end find_new_bsm_index()
1288
1289
1290 // The bug 6214132 caused the verification to fail.
1291 // 1. What's done in RedefineClasses() before verification:
1292 // a) A reference to the class being redefined (_the_class) and a
1293 // reference to new version of the class (_scratch_class) are
1294 // saved here for use during the bytecode verification phase of
1295 // RedefineClasses.
1296 // b) The _java_mirror field from _the_class is copied to the
1297 // _java_mirror field in _scratch_class. This means that a jclass
1298 // returned for _the_class or _scratch_class will refer to the
1299 // same Java mirror. The verifier will see the "one true mirror"
1300 // for the class being verified.
1301 // 2. See comments in JvmtiThreadState for what is done during verification.
1302
1303 class RedefineVerifyMark : public StackObj {
1304 private:
1305 JvmtiThreadState* _state;
1306 InstanceKlass* _scratch_class;
1307 OopHandle _scratch_mirror;
1308
1309 public:
1310
1311 RedefineVerifyMark(InstanceKlass* the_class, InstanceKlass* scratch_class,
1312 JvmtiThreadState* state) : _state(state), _scratch_class(scratch_class)
1313 {
1314 _state->set_class_versions_map(the_class, scratch_class);
1315 _scratch_mirror = the_class->java_mirror_handle(); // this is a copy that is swapped
1316 _scratch_class->swap_java_mirror_handle(_scratch_mirror);
1317 }
1318
1319 ~RedefineVerifyMark() {
1320 // Restore the scratch class's mirror, so when scratch_class is removed
1321 // the correct mirror pointing to it can be cleared.
1322 _scratch_class->swap_java_mirror_handle(_scratch_mirror);
1323 _state->clear_class_versions_map();
1324 }
1325 };
1326
1327
1328 jvmtiError VM_RedefineClasses::load_new_class_versions() {
1329
1330 // For consistency allocate memory using os::malloc wrapper.
1331 _scratch_classes = (InstanceKlass**)
1332 os::malloc(sizeof(InstanceKlass*) * _class_count, mtClass);
1333 if (_scratch_classes == nullptr) {
1334 return JVMTI_ERROR_OUT_OF_MEMORY;
1335 }
1336 // Zero initialize the _scratch_classes array.
1337 for (int i = 0; i < _class_count; i++) {
1338 _scratch_classes[i] = nullptr;
1339 }
1340
1341 JavaThread* current = JavaThread::current();
1342 ResourceMark rm(current);
1343
1344 JvmtiThreadState *state = JvmtiThreadState::state_for(current);
1345 // state can only be null if the current thread is exiting which
1346 // should not happen since we're trying to do a RedefineClasses
1347 guarantee(state != nullptr, "exiting thread calling load_new_class_versions");
1348 for (int i = 0; i < _class_count; i++) {
1349 // Create HandleMark so that any handles created while loading new class
1350 // versions are deleted. Constant pools are deallocated while merging
1351 // constant pools
1352 HandleMark hm(current);
1353 InstanceKlass* the_class = get_ik(_class_defs[i].klass);
1354 physical_memory_size_type avail_mem = 0;
1355 // Return value ignored - defaulting to 0 on failure.
1356 (void)os::available_memory(avail_mem);
1357 log_debug(redefine, class, load)
1358 ("loading name=%s kind=%d (avail_mem=" PHYS_MEM_TYPE_FORMAT "K)",
1359 the_class->external_name(), _class_load_kind, avail_mem >> 10);
1360
1361 ClassFileStream st((u1*)_class_defs[i].class_bytes,
1362 _class_defs[i].class_byte_count,
1363 "__VM_RedefineClasses__");
1364
1365 // Set redefined class handle in JvmtiThreadState class.
1366 // This redefined class is sent to agent event handler for class file
1367 // load hook event.
1368 state->set_class_being_redefined(the_class, _class_load_kind);
1369
1370 JavaThread* THREAD = current; // For exception macros.
1371 ExceptionMark em(THREAD);
1372 Handle protection_domain(THREAD, the_class->protection_domain());
1373 ClassLoadInfo cl_info(protection_domain);
1374 // Parse and create a class from the bytes, but this class isn't added
1375 // to the dictionary, so do not call resolve_from_stream.
1376 InstanceKlass* scratch_class = KlassFactory::create_from_stream(&st,
1377 the_class->name(),
1378 the_class->class_loader_data(),
1379 cl_info,
1380 THREAD);
1381
1382 // Clear class_being_redefined just to be sure.
1383 state->clear_class_being_redefined();
1384
1385 // TODO: if this is retransform, and nothing changed we can skip it
1386
1387 // Need to clean up allocated InstanceKlass if there's an error so assign
1388 // the result here. Caller deallocates all the scratch classes in case of
1389 // an error.
1390 _scratch_classes[i] = scratch_class;
1391
1392 if (HAS_PENDING_EXCEPTION) {
1393 Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
1394 log_info(redefine, class, load, exceptions)("create_from_stream exception: '%s'", ex_name->as_C_string());
1395 CLEAR_PENDING_EXCEPTION;
1396
1397 if (ex_name == vmSymbols::java_lang_UnsupportedClassVersionError()) {
1398 return JVMTI_ERROR_UNSUPPORTED_VERSION;
1399 } else if (ex_name == vmSymbols::java_lang_ClassFormatError()) {
1400 return JVMTI_ERROR_INVALID_CLASS_FORMAT;
1401 } else if (ex_name == vmSymbols::java_lang_ClassCircularityError()) {
1402 return JVMTI_ERROR_CIRCULAR_CLASS_DEFINITION;
1403 } else if (ex_name == vmSymbols::java_lang_NoClassDefFoundError()) {
1404 // The message will be "XXX (wrong name: YYY)"
1405 return JVMTI_ERROR_NAMES_DONT_MATCH;
1406 } else if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) {
1407 return JVMTI_ERROR_OUT_OF_MEMORY;
1408 } else { // Just in case more exceptions can be thrown..
1409 return JVMTI_ERROR_FAILS_VERIFICATION;
1410 }
1411 }
1412
1413 // Ensure class is linked before redefine
1414 if (!the_class->is_linked()) {
1415 the_class->link_class(THREAD);
1416 if (HAS_PENDING_EXCEPTION) {
1417 Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
1418 oop message = java_lang_Throwable::message(PENDING_EXCEPTION);
1419 if (message != nullptr) {
1420 char* ex_msg = java_lang_String::as_utf8_string(message);
1421 log_info(redefine, class, load, exceptions)("link_class exception: '%s %s'",
1422 ex_name->as_C_string(), ex_msg);
1423 } else {
1424 log_info(redefine, class, load, exceptions)("link_class exception: '%s'",
1425 ex_name->as_C_string());
1426 }
1427 CLEAR_PENDING_EXCEPTION;
1428 if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) {
1429 return JVMTI_ERROR_OUT_OF_MEMORY;
1430 } else if (ex_name == vmSymbols::java_lang_NoClassDefFoundError()) {
1431 return JVMTI_ERROR_INVALID_CLASS;
1432 } else {
1433 return JVMTI_ERROR_INTERNAL;
1434 }
1435 }
1436 }
1437
1438 // Do the validity checks in compare_and_normalize_class_versions()
1439 // before verifying the byte codes. By doing these checks first, we
1440 // limit the number of functions that require redirection from
1441 // the_class to scratch_class. In particular, we don't have to
1442 // modify JNI GetSuperclass() and thus won't change its performance.
1443 jvmtiError res = compare_and_normalize_class_versions(the_class,
1444 scratch_class);
1445 if (res != JVMTI_ERROR_NONE) {
1446 return res;
1447 }
1448
1449 // verify what the caller passed us
1450 {
1451 // The bug 6214132 caused the verification to fail.
1452 // Information about the_class and scratch_class is temporarily
1453 // recorded into jvmtiThreadState. This data is used to redirect
1454 // the_class to scratch_class in the JVM_* functions called by the
1455 // verifier. Please, refer to jvmtiThreadState.hpp for the detailed
1456 // description.
1457 RedefineVerifyMark rvm(the_class, scratch_class, state);
1458 Verifier::verify(scratch_class, true, THREAD);
1459 }
1460
1461 if (HAS_PENDING_EXCEPTION) {
1462 Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
1463 log_info(redefine, class, load, exceptions)("verify_byte_codes exception: '%s'", ex_name->as_C_string());
1464 CLEAR_PENDING_EXCEPTION;
1465 if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) {
1466 return JVMTI_ERROR_OUT_OF_MEMORY;
1467 } else {
1468 // tell the caller the bytecodes are bad
1469 return JVMTI_ERROR_FAILS_VERIFICATION;
1470 }
1471 }
1472
1473 res = merge_cp_and_rewrite(the_class, scratch_class, THREAD);
1474 if (HAS_PENDING_EXCEPTION) {
1475 Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
1476 log_info(redefine, class, load, exceptions)("merge_cp_and_rewrite exception: '%s'", ex_name->as_C_string());
1477 CLEAR_PENDING_EXCEPTION;
1478 if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) {
1479 return JVMTI_ERROR_OUT_OF_MEMORY;
1480 } else {
1481 return JVMTI_ERROR_INTERNAL;
1482 }
1483 }
1484
1485 #ifdef ASSERT
1486 {
1487 // verify what we have done during constant pool merging
1488 {
1489 RedefineVerifyMark rvm(the_class, scratch_class, state);
1490 Verifier::verify(scratch_class, true, THREAD);
1491 }
1492
1493 if (HAS_PENDING_EXCEPTION) {
1494 Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
1495 log_info(redefine, class, load, exceptions)
1496 ("verify_byte_codes post merge-CP exception: '%s'", ex_name->as_C_string());
1497 CLEAR_PENDING_EXCEPTION;
1498 if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) {
1499 return JVMTI_ERROR_OUT_OF_MEMORY;
1500 } else {
1501 // tell the caller that constant pool merging screwed up
1502 return JVMTI_ERROR_INTERNAL;
1503 }
1504 }
1505 }
1506 #endif // ASSERT
1507
1508 Rewriter::rewrite(scratch_class, THREAD);
1509 if (!HAS_PENDING_EXCEPTION) {
1510 scratch_class->link_methods(THREAD);
1511 }
1512 if (HAS_PENDING_EXCEPTION) {
1513 Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
1514 log_info(redefine, class, load, exceptions)
1515 ("Rewriter::rewrite or link_methods exception: '%s'", ex_name->as_C_string());
1516 CLEAR_PENDING_EXCEPTION;
1517 if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) {
1518 return JVMTI_ERROR_OUT_OF_MEMORY;
1519 } else {
1520 return JVMTI_ERROR_INTERNAL;
1521 }
1522 }
1523 // Return value ignored - defaulting to 0 on failure.
1524 (void)os::available_memory(avail_mem);
1525 log_debug(redefine, class, load)
1526 ("loaded name=%s (avail_mem=" PHYS_MEM_TYPE_FORMAT "K)", the_class->external_name(), avail_mem >> 10);
1527 }
1528
1529 return JVMTI_ERROR_NONE;
1530 }
1531
1532
1533 // Map old_index to new_index as needed. scratch_cp is only needed
1534 // for log calls.
1535 void VM_RedefineClasses::map_index(const constantPoolHandle& scratch_cp,
1536 int old_index, int new_index) {
1537 if (find_new_index(old_index) != 0) {
1538 // old_index is already mapped
1539 return;
1540 }
1541
1542 if (old_index == new_index) {
1543 // no mapping is needed
1544 return;
1545 }
1546
1547 _index_map_p->at_put(old_index, new_index);
1548 _index_map_count++;
1549
1550 log_trace(redefine, class, constantpool)
1551 ("mapped tag %d at index %d to %d", scratch_cp->tag_at(old_index).value(), old_index, new_index);
1552 } // end map_index()
1553
1554
1555 // Map old_index to new_index as needed.
1556 void VM_RedefineClasses::map_bsm_index(int old_index, int new_index) {
1557 if (old_index == new_index) {
1558 // no mapping is needed
1559 return;
1560 }
1561 _bsm_index_map_p->at_put(old_index, new_index);
1562 _bsm_index_map_count++;
1563 log_trace(redefine, class, constantpool)("mapped bootstrap specifier at index %d to %d", old_index, new_index);
1564 } // end map_bsm_index()
1565
1566
1567 // Merge old_cp and scratch_cp and return the results of the merge via
1568 // merge_cp_p. The number of entries in merge_cp_p is returned via
1569 // merge_cp_length_p. The entries in old_cp occupy the same locations
1570 // in merge_cp_p. Also creates a map of indices from entries in
1571 // scratch_cp to the corresponding entry in merge_cp_p. Index map
1572 // entries are only created for entries in scratch_cp that occupy a
1573 // different location in merged_cp_p.
1574 bool VM_RedefineClasses::merge_constant_pools(const constantPoolHandle& old_cp,
1575 const constantPoolHandle& scratch_cp, constantPoolHandle& merge_cp_p,
1576 int& merge_cp_length_p, TRAPS) {
1577
1578 // Worst case we need old_cp->length() + scratch_cp()->length(),
1579 // but the caller might be smart so make sure we have at least
1580 // the minimum.
1581 if (merge_cp_p->length() < old_cp->length()) {
1582 assert(false, "merge area too small");
1583 return false; // robustness
1584 }
1585
1586 log_info(redefine, class, constantpool)("old_cp_len=%d, scratch_cp_len=%d", old_cp->length(), scratch_cp->length());
1587
1588 {
1589 // Pass 0:
1590 // The old_cp is copied to *merge_cp_p; this means that any code
1591 // using old_cp does not have to change. This work looks like a
1592 // perfect fit for ConstantPool*::copy_cp_to(), but we need to
1593 // handle one special case:
1594 // - revert JVM_CONSTANT_Class to JVM_CONSTANT_UnresolvedClass
1595 // This will make verification happy.
1596
1597 int old_i; // index into old_cp
1598
1599 // index zero (0) is not used in constantPools
1600 for (old_i = 1; old_i < old_cp->length(); old_i++) {
1601 // leave debugging crumb
1602 jbyte old_tag = old_cp->tag_at(old_i).value();
1603 switch (old_tag) {
1604 case JVM_CONSTANT_Class:
1605 case JVM_CONSTANT_UnresolvedClass:
1606 // revert the copy to JVM_CONSTANT_UnresolvedClass
1607 // May be resolving while calling this so do the same for
1608 // JVM_CONSTANT_UnresolvedClass (klass_name_at() deals with transition)
1609 merge_cp_p->temp_unresolved_klass_at_put(old_i,
1610 old_cp->klass_name_index_at(old_i));
1611 break;
1612
1613 case JVM_CONSTANT_Double:
1614 case JVM_CONSTANT_Long:
1615 // just copy the entry to merge_cp_p, but double and long take
1616 // two constant pool entries
1617 ConstantPool::copy_entry_to(old_cp, old_i, merge_cp_p, old_i);
1618 old_i++;
1619 break;
1620
1621 default:
1622 // just copy the entry to merge_cp_p
1623 ConstantPool::copy_entry_to(old_cp, old_i, merge_cp_p, old_i);
1624 break;
1625 }
1626 } // end for each old_cp entry
1627
1628 ConstantPool::copy_bsm_entries(old_cp, merge_cp_p, CHECK_false);
1629 _bsmae_iter = merge_cp_p->start_extension(scratch_cp, CHECK_false);
1630
1631 // We don't need to sanity check that *merge_cp_length_p is within
1632 // *merge_cp_p bounds since we have the minimum on-entry check above.
1633 merge_cp_length_p = old_i;
1634 }
1635
1636 // merge_cp_len should be the same as old_cp->length() at this point
1637 // so this trace message is really a "warm-and-breathing" message.
1638 log_debug(redefine, class, constantpool)("after pass 0: merge_cp_len=%d", merge_cp_length_p);
1639
1640 int scratch_i; // index into scratch_cp
1641 {
1642 // Pass 1a:
1643 // Compare scratch_cp entries to the old_cp entries that we have
1644 // already copied to *merge_cp_p. In this pass, we are eliminating
1645 // exact duplicates (matching entry at same index) so we only
1646 // compare entries in the common indice range.
1647 int increment = 1;
1648 int pass1a_length = MIN2(old_cp->length(), scratch_cp->length());
1649 for (scratch_i = 1; scratch_i < pass1a_length; scratch_i += increment) {
1650 switch (scratch_cp->tag_at(scratch_i).value()) {
1651 case JVM_CONSTANT_Double:
1652 case JVM_CONSTANT_Long:
1653 // double and long take two constant pool entries
1654 increment = 2;
1655 break;
1656
1657 default:
1658 increment = 1;
1659 break;
1660 }
1661
1662 bool match = scratch_cp->compare_entry_to(scratch_i, merge_cp_p, scratch_i);
1663 if (match) {
1664 // found a match at the same index so nothing more to do
1665 continue;
1666 }
1667
1668 int found_i = scratch_cp->find_matching_entry(scratch_i, merge_cp_p);
1669 if (found_i != 0) {
1670 guarantee(found_i != scratch_i,
1671 "compare_entry_to() and find_matching_entry() do not agree");
1672
1673 // Found a matching entry somewhere else in *merge_cp_p so
1674 // just need a mapping entry.
1675 map_index(scratch_cp, scratch_i, found_i);
1676 continue;
1677 }
1678
1679 // No match found so we have to append this entry and any unique
1680 // referenced entries to merge_cp_p.
1681 append_entry(scratch_cp, scratch_i, &merge_cp_p, &merge_cp_length_p);
1682 }
1683 }
1684
1685 log_debug(redefine, class, constantpool)
1686 ("after pass 1a: merge_cp_len=%d, scratch_i=%d, index_map_len=%d",
1687 merge_cp_length_p, scratch_i, _index_map_count);
1688
1689 if (scratch_i < scratch_cp->length()) {
1690 // Pass 1b:
1691 // old_cp is smaller than scratch_cp so there are entries in
1692 // scratch_cp that we have not yet processed. We take care of
1693 // those now.
1694 int increment = 1;
1695 for (; scratch_i < scratch_cp->length(); scratch_i += increment) {
1696 switch (scratch_cp->tag_at(scratch_i).value()) {
1697 case JVM_CONSTANT_Double:
1698 case JVM_CONSTANT_Long:
1699 // double and long take two constant pool entries
1700 increment = 2;
1701 break;
1702
1703 default:
1704 increment = 1;
1705 break;
1706 }
1707
1708 int found_i =
1709 scratch_cp->find_matching_entry(scratch_i, merge_cp_p);
1710 if (found_i != 0) {
1711 // Found a matching entry somewhere else in merge_cp_p so
1712 // just need a mapping entry.
1713 map_index(scratch_cp, scratch_i, found_i);
1714 continue;
1715 }
1716
1717 // No match found so we have to append this entry and any unique
1718 // referenced entries to merge_cp_p.
1719 append_entry(scratch_cp, scratch_i, &merge_cp_p, &merge_cp_length_p);
1720 }
1721
1722 log_debug(redefine, class, constantpool)
1723 ("after pass 1b: merge_cp_len=%d, scratch_i=%d, index_map_len=%d",
1724 merge_cp_length_p, scratch_i, _index_map_count);
1725 }
1726 finalize_bsm_entries_merge(merge_cp_p, CHECK_false);
1727
1728 return true;
1729 } // end merge_constant_pools()
1730
1731
1732 // Scoped object to clean up the constant pool(s) created for merging
1733 class MergeCPCleaner {
1734 ClassLoaderData* _loader_data;
1735 ConstantPool* _cp;
1736 ConstantPool* _scratch_cp;
1737 public:
1738 MergeCPCleaner(ClassLoaderData* loader_data, ConstantPool* merge_cp) :
1739 _loader_data(loader_data), _cp(merge_cp), _scratch_cp(nullptr) {}
1740 ~MergeCPCleaner() {
1741 _loader_data->add_to_deallocate_list(_cp);
1742 if (_scratch_cp != nullptr) {
1743 _loader_data->add_to_deallocate_list(_scratch_cp);
1744 }
1745 }
1746 void add_scratch_cp(ConstantPool* scratch_cp) { _scratch_cp = scratch_cp; }
1747 };
1748
1749 // Merge constant pools between the_class and scratch_class and
1750 // potentially rewrite bytecodes in scratch_class to use the merged
1751 // constant pool.
1752 jvmtiError VM_RedefineClasses::merge_cp_and_rewrite(
1753 InstanceKlass* the_class, InstanceKlass* scratch_class,
1754 TRAPS) {
1755 // worst case merged constant pool length is old and new combined
1756 int merge_cp_length = the_class->constants()->length()
1757 + scratch_class->constants()->length();
1758
1759 // Constant pools are not easily reused so we allocate a new one
1760 // each time.
1761 // merge_cp is created unsafe for concurrent GC processing. It
1762 // should be marked safe before discarding it. Even though
1763 // garbage, if it crosses a card boundary, it may be scanned
1764 // in order to find the start of the first complete object on the card.
1765 ClassLoaderData* loader_data = the_class->class_loader_data();
1766 ConstantPool* merge_cp_oop =
1767 ConstantPool::allocate(loader_data,
1768 merge_cp_length,
1769 CHECK_(JVMTI_ERROR_OUT_OF_MEMORY));
1770 MergeCPCleaner cp_cleaner(loader_data, merge_cp_oop);
1771
1772 HandleMark hm(THREAD); // make sure handles are cleared before
1773 // MergeCPCleaner clears out merge_cp_oop
1774 constantPoolHandle merge_cp(THREAD, merge_cp_oop);
1775
1776 // Get constants() from the old class because it could have been rewritten
1777 // while we were at a safepoint allocating a new constant pool.
1778 constantPoolHandle old_cp(THREAD, the_class->constants());
1779 constantPoolHandle scratch_cp(THREAD, scratch_class->constants());
1780
1781 // If the length changed, the class was redefined out from under us. Return
1782 // an error.
1783 if (merge_cp_length != the_class->constants()->length()
1784 + scratch_class->constants()->length()) {
1785 return JVMTI_ERROR_INTERNAL;
1786 }
1787
1788 // Update the version number of the constant pools (may keep scratch_cp)
1789 merge_cp->increment_and_save_version(old_cp->version());
1790 scratch_cp->increment_and_save_version(old_cp->version());
1791
1792 ResourceMark rm(THREAD);
1793 _index_map_count = 0;
1794 _index_map_p = new intArray(scratch_cp->length(), scratch_cp->length(), -1);
1795
1796 _bsm_index_map_count = 0;
1797 int bsm_data_len = scratch_cp->bsm_entries().array_length();
1798 _bsm_index_map_p = new intArray(bsm_data_len, bsm_data_len, -1);
1799
1800 // reference to the cp holder is needed for reallocating the BSM attribute
1801 merge_cp->set_pool_holder(scratch_class);
1802 bool result = merge_constant_pools(old_cp, scratch_cp, merge_cp,
1803 merge_cp_length, THREAD);
1804 merge_cp->set_pool_holder(nullptr);
1805
1806 if (!result) {
1807 // The merge can fail due to memory allocation failure or due
1808 // to robustness checks.
1809 return JVMTI_ERROR_INTERNAL;
1810 }
1811
1812 // ensure merged constant pool size does not overflow u2
1813 if (merge_cp_length > 0xFFFF) {
1814 log_warning(redefine, class, constantpool)("Merged constant pool overflow: %d entries", merge_cp_length);
1815 return JVMTI_ERROR_INTERNAL;
1816 }
1817
1818 // Set dynamic constants attribute from the original CP.
1819 if (old_cp->has_dynamic_constant()) {
1820 scratch_cp->set_has_dynamic_constant();
1821 }
1822
1823 log_info(redefine, class, constantpool)("merge_cp_len=%d, index_map_len=%d", merge_cp_length, _index_map_count);
1824
1825 if (_index_map_count == 0) {
1826 // there is nothing to map between the new and merged constant pools
1827
1828 // Copy attributes from scratch_cp to merge_cp
1829 merge_cp->copy_fields(scratch_cp());
1830
1831 if (old_cp->length() == scratch_cp->length()) {
1832 // The old and new constant pools are the same length and the
1833 // index map is empty. This means that the three constant pools
1834 // are equivalent (but not the same). Unfortunately, the new
1835 // constant pool has not gone through link resolution nor have
1836 // the new class bytecodes gone through constant pool cache
1837 // rewriting so we can't use the old constant pool with the new
1838 // class.
1839
1840 // toss the merged constant pool at return
1841 } else if (old_cp->length() < scratch_cp->length()) {
1842 // The old constant pool has fewer entries than the new constant
1843 // pool and the index map is empty. This means the new constant
1844 // pool is a superset of the old constant pool. However, the old
1845 // class bytecodes have already gone through constant pool cache
1846 // rewriting so we can't use the new constant pool with the old
1847 // class.
1848
1849 // toss the merged constant pool at return
1850 } else {
1851 // The old constant pool has more entries than the new constant
1852 // pool and the index map is empty. This means that both the old
1853 // and merged constant pools are supersets of the new constant
1854 // pool.
1855
1856 // Replace the new constant pool with a shrunken copy of the
1857 // merged constant pool
1858 set_new_constant_pool(loader_data, scratch_class, merge_cp, merge_cp_length,
1859 CHECK_(JVMTI_ERROR_OUT_OF_MEMORY));
1860 // The new constant pool replaces scratch_cp so have cleaner clean it up.
1861 // It can't be cleaned up while there are handles to it.
1862 cp_cleaner.add_scratch_cp(scratch_cp());
1863 }
1864 } else {
1865 if (log_is_enabled(Trace, redefine, class, constantpool)) {
1866 // don't want to loop unless we are tracing
1867 int count = 0;
1868 for (int i = 1; i < _index_map_p->length(); i++) {
1869 int value = _index_map_p->at(i);
1870
1871 if (value != -1) {
1872 log_trace(redefine, class, constantpool)("index_map[%d]: old=%d new=%d", count, i, value);
1873 count++;
1874 }
1875 }
1876 }
1877
1878 // We have entries mapped between the new and merged constant pools
1879 // so we have to rewrite some constant pool references.
1880 if (!rewrite_cp_refs(scratch_class)) {
1881 return JVMTI_ERROR_INTERNAL;
1882 }
1883
1884 // Copy attributes from scratch_cp to merge_cp (should be done after rewrite_cp_refs())
1885 merge_cp->copy_fields(scratch_cp());
1886
1887 // Replace the new constant pool with a shrunken copy of the
1888 // merged constant pool so now the rewritten bytecodes have
1889 // valid references; the previous new constant pool will get
1890 // GCed.
1891 set_new_constant_pool(loader_data, scratch_class, merge_cp, merge_cp_length,
1892 CHECK_(JVMTI_ERROR_OUT_OF_MEMORY));
1893 // The new constant pool replaces scratch_cp so have cleaner clean it up.
1894 // It can't be cleaned up while there are handles to it.
1895 cp_cleaner.add_scratch_cp(scratch_cp());
1896 }
1897
1898 return JVMTI_ERROR_NONE;
1899 } // end merge_cp_and_rewrite()
1900
1901
1902 // Rewrite constant pool references in klass scratch_class.
1903 bool VM_RedefineClasses::rewrite_cp_refs(InstanceKlass* scratch_class) {
1904
1905 // rewrite constant pool references in the nest attributes:
1906 if (!rewrite_cp_refs_in_nest_attributes(scratch_class)) {
1907 // propagate failure back to caller
1908 return false;
1909 }
1910
1911 // rewrite constant pool references in the Record attribute:
1912 if (!rewrite_cp_refs_in_record_attribute(scratch_class)) {
1913 // propagate failure back to caller
1914 return false;
1915 }
1916
1917 // rewrite constant pool references in the PermittedSubclasses attribute:
1918 if (!rewrite_cp_refs_in_permitted_subclasses_attribute(scratch_class)) {
1919 // propagate failure back to caller
1920 return false;
1921 }
1922
1923 // rewrite constant pool references in the LoadableDescriptors attribute:
1924 if (!rewrite_cp_refs_in_loadable_descriptors_attribute(scratch_class)) {
1925 // propagate failure back to caller
1926 return false;
1927 }
1928
1929 // rewrite constant pool references in the methods:
1930 if (!rewrite_cp_refs_in_methods(scratch_class)) {
1931 // propagate failure back to caller
1932 return false;
1933 }
1934
1935 // rewrite constant pool references in the class_annotations:
1936 if (!rewrite_cp_refs_in_class_annotations(scratch_class)) {
1937 // propagate failure back to caller
1938 return false;
1939 }
1940
1941 // rewrite constant pool references in the fields_annotations:
1942 if (!rewrite_cp_refs_in_fields_annotations(scratch_class)) {
1943 // propagate failure back to caller
1944 return false;
1945 }
1946
1947 // rewrite constant pool references in the methods_annotations:
1948 if (!rewrite_cp_refs_in_methods_annotations(scratch_class)) {
1949 // propagate failure back to caller
1950 return false;
1951 }
1952
1953 // rewrite constant pool references in the methods_parameter_annotations:
1954 if (!rewrite_cp_refs_in_methods_parameter_annotations(scratch_class)) {
1955 // propagate failure back to caller
1956 return false;
1957 }
1958
1959 // rewrite constant pool references in the methods_default_annotations:
1960 if (!rewrite_cp_refs_in_methods_default_annotations(scratch_class)) {
1961 // propagate failure back to caller
1962 return false;
1963 }
1964
1965 // rewrite constant pool references in the class_type_annotations:
1966 if (!rewrite_cp_refs_in_class_type_annotations(scratch_class)) {
1967 // propagate failure back to caller
1968 return false;
1969 }
1970
1971 // rewrite constant pool references in the fields_type_annotations:
1972 if (!rewrite_cp_refs_in_fields_type_annotations(scratch_class)) {
1973 // propagate failure back to caller
1974 return false;
1975 }
1976
1977 // rewrite constant pool references in the methods_type_annotations:
1978 if (!rewrite_cp_refs_in_methods_type_annotations(scratch_class)) {
1979 // propagate failure back to caller
1980 return false;
1981 }
1982
1983 // There can be type annotations in the Code part of a method_info attribute.
1984 // These annotations are not accessible, even by reflection.
1985 // Currently they are not even parsed by the ClassFileParser.
1986 // If runtime access is added they will also need to be rewritten.
1987
1988 // rewrite source file name index:
1989 u2 source_file_name_idx = scratch_class->source_file_name_index();
1990 if (source_file_name_idx != 0) {
1991 u2 new_source_file_name_idx = find_new_index(source_file_name_idx);
1992 if (new_source_file_name_idx != 0) {
1993 scratch_class->set_source_file_name_index(new_source_file_name_idx);
1994 }
1995 }
1996
1997 // rewrite class generic signature index:
1998 u2 generic_signature_index = scratch_class->generic_signature_index();
1999 if (generic_signature_index != 0) {
2000 u2 new_generic_signature_index = find_new_index(generic_signature_index);
2001 if (new_generic_signature_index != 0) {
2002 scratch_class->set_generic_signature_index(new_generic_signature_index);
2003 }
2004 }
2005
2006 return true;
2007 } // end rewrite_cp_refs()
2008
2009 // Rewrite constant pool references in the NestHost and NestMembers attributes.
2010 bool VM_RedefineClasses::rewrite_cp_refs_in_nest_attributes(
2011 InstanceKlass* scratch_class) {
2012
2013 u2 cp_index = scratch_class->nest_host_index();
2014 if (cp_index != 0) {
2015 scratch_class->set_nest_host_index(find_new_index(cp_index));
2016 }
2017 Array<u2>* nest_members = scratch_class->nest_members();
2018 for (int i = 0; i < nest_members->length(); i++) {
2019 u2 cp_index = nest_members->at(i);
2020 nest_members->at_put(i, find_new_index(cp_index));
2021 }
2022 return true;
2023 }
2024
2025 // Rewrite constant pool references in the Record attribute.
2026 bool VM_RedefineClasses::rewrite_cp_refs_in_record_attribute(InstanceKlass* scratch_class) {
2027 Array<RecordComponent*>* components = scratch_class->record_components();
2028 if (components != nullptr) {
2029 for (int i = 0; i < components->length(); i++) {
2030 RecordComponent* component = components->at(i);
2031 u2 cp_index = component->name_index();
2032 component->set_name_index(find_new_index(cp_index));
2033 cp_index = component->descriptor_index();
2034 component->set_descriptor_index(find_new_index(cp_index));
2035 cp_index = component->generic_signature_index();
2036 if (cp_index != 0) {
2037 component->set_generic_signature_index(find_new_index(cp_index));
2038 }
2039
2040 AnnotationArray* annotations = component->annotations();
2041 if (annotations != nullptr && annotations->length() != 0) {
2042 int byte_i = 0; // byte index into annotations
2043 if (!rewrite_cp_refs_in_annotations_typeArray(annotations, byte_i)) {
2044 log_debug(redefine, class, annotation)("bad record_component_annotations at %d", i);
2045 // propagate failure back to caller
2046 return false;
2047 }
2048 }
2049
2050 AnnotationArray* type_annotations = component->type_annotations();
2051 if (type_annotations != nullptr && type_annotations->length() != 0) {
2052 int byte_i = 0; // byte index into annotations
2053 if (!rewrite_cp_refs_in_annotations_typeArray(type_annotations, byte_i)) {
2054 log_debug(redefine, class, annotation)("bad record_component_type_annotations at %d", i);
2055 // propagate failure back to caller
2056 return false;
2057 }
2058 }
2059 }
2060 }
2061 return true;
2062 }
2063
2064 // Rewrite constant pool references in the PermittedSubclasses attribute.
2065 bool VM_RedefineClasses::rewrite_cp_refs_in_permitted_subclasses_attribute(
2066 InstanceKlass* scratch_class) {
2067
2068 Array<u2>* permitted_subclasses = scratch_class->permitted_subclasses();
2069 assert(permitted_subclasses != nullptr, "unexpected null permitted_subclasses");
2070 for (int i = 0; i < permitted_subclasses->length(); i++) {
2071 u2 cp_index = permitted_subclasses->at(i);
2072 permitted_subclasses->at_put(i, find_new_index(cp_index));
2073 }
2074 return true;
2075 }
2076
2077 // Rewrite constant pool references in the LoadableDescriptors attribute.
2078 bool VM_RedefineClasses::rewrite_cp_refs_in_loadable_descriptors_attribute(
2079 InstanceKlass* scratch_class) {
2080
2081 Array<u2>* loadable_descriptors = scratch_class->loadable_descriptors();
2082 assert(loadable_descriptors != nullptr, "unexpected null loadable_descriptors");
2083 for (int i = 0; i < loadable_descriptors->length(); i++) {
2084 u2 cp_index = loadable_descriptors->at(i);
2085 loadable_descriptors->at_put(i, find_new_index(cp_index));
2086 }
2087 return true;
2088 }
2089
2090 // Rewrite constant pool references in the methods.
2091 bool VM_RedefineClasses::rewrite_cp_refs_in_methods(InstanceKlass* scratch_class) {
2092
2093 Array<Method*>* methods = scratch_class->methods();
2094
2095 if (methods == nullptr || methods->length() == 0) {
2096 // no methods so nothing to do
2097 return true;
2098 }
2099
2100 JavaThread* THREAD = JavaThread::current(); // For exception macros.
2101 ExceptionMark em(THREAD);
2102
2103 // rewrite constant pool references in the methods:
2104 for (int i = methods->length() - 1; i >= 0; i--) {
2105 methodHandle method(THREAD, methods->at(i));
2106 methodHandle new_method;
2107 rewrite_cp_refs_in_method(method, &new_method, THREAD);
2108 if (!new_method.is_null()) {
2109 // the method has been replaced so save the new method version
2110 // even in the case of an exception. original method is on the
2111 // deallocation list.
2112 methods->at_put(i, new_method());
2113 }
2114 if (HAS_PENDING_EXCEPTION) {
2115 Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
2116 log_info(redefine, class, load, exceptions)("rewrite_cp_refs_in_method exception: '%s'", ex_name->as_C_string());
2117 // Need to clear pending exception here as the super caller sets
2118 // the JVMTI_ERROR_INTERNAL if the returned value is false.
2119 CLEAR_PENDING_EXCEPTION;
2120 return false;
2121 }
2122 }
2123
2124 return true;
2125 }
2126
2127
2128 // Rewrite constant pool references in the specific method. This code
2129 // was adapted from Rewriter::rewrite_method().
2130 void VM_RedefineClasses::rewrite_cp_refs_in_method(methodHandle method,
2131 methodHandle *new_method_p, TRAPS) {
2132
2133 *new_method_p = methodHandle(); // default is no new method
2134
2135 // We cache a pointer to the bytecodes here in code_base. If GC
2136 // moves the Method*, then the bytecodes will also move which
2137 // will likely cause a crash. We create a NoSafepointVerifier
2138 // object to detect whether we pass a possible safepoint in this
2139 // code block.
2140 NoSafepointVerifier nsv;
2141
2142 // Bytecodes and their length
2143 address code_base = method->code_base();
2144 int code_length = method->code_size();
2145
2146 int bc_length;
2147 for (int bci = 0; bci < code_length; bci += bc_length) {
2148 address bcp = code_base + bci;
2149 Bytecodes::Code c = (Bytecodes::Code)(*bcp);
2150
2151 bc_length = Bytecodes::length_for(c);
2152 if (bc_length == 0) {
2153 // More complicated bytecodes report a length of zero so
2154 // we have to try again a slightly different way.
2155 bc_length = Bytecodes::length_at(method(), bcp);
2156 }
2157
2158 assert(bc_length != 0, "impossible bytecode length");
2159
2160 switch (c) {
2161 case Bytecodes::_ldc:
2162 {
2163 u1 cp_index = *(bcp + 1);
2164 u2 new_index = find_new_index(cp_index);
2165
2166 if (StressLdcRewrite && new_index == 0) {
2167 // If we are stressing ldc -> ldc_w rewriting, then we
2168 // always need a new_index value.
2169 new_index = cp_index;
2170 }
2171 if (new_index != 0) {
2172 // the original index is mapped so we have more work to do
2173 if (!StressLdcRewrite && new_index <= max_jubyte) {
2174 // The new value can still use ldc instead of ldc_w
2175 // unless we are trying to stress ldc -> ldc_w rewriting
2176 log_trace(redefine, class, constantpool)
2177 ("%s@" INTPTR_FORMAT " old=%d, new=%d", Bytecodes::name(c), p2i(bcp), cp_index, new_index);
2178 // We checked that new_index fits in a u1 so this cast is safe
2179 *(bcp + 1) = (u1)new_index;
2180 } else {
2181 log_trace(redefine, class, constantpool)
2182 ("%s->ldc_w@" INTPTR_FORMAT " old=%d, new=%d", Bytecodes::name(c), p2i(bcp), cp_index, new_index);
2183 // the new value needs ldc_w instead of ldc
2184 u_char inst_buffer[4]; // max instruction size is 4 bytes
2185 bcp = (address)inst_buffer;
2186 // construct new instruction sequence
2187 *bcp = Bytecodes::_ldc_w;
2188 bcp++;
2189 // Rewriter::rewrite_method() does not rewrite ldc -> ldc_w.
2190 // See comment below for difference between put_Java_u2()
2191 // and put_native_u2().
2192 Bytes::put_Java_u2(bcp, new_index);
2193
2194 Relocator rc(method, nullptr /* no RelocatorListener needed */);
2195 methodHandle m;
2196 {
2197 PauseNoSafepointVerifier pnsv(&nsv);
2198
2199 // ldc is 2 bytes and ldc_w is 3 bytes
2200 m = rc.insert_space_at(bci, 3, inst_buffer, CHECK);
2201 }
2202
2203 // return the new method so that the caller can update
2204 // the containing class
2205 *new_method_p = method = m;
2206 // switch our bytecode processing loop from the old method
2207 // to the new method
2208 code_base = method->code_base();
2209 code_length = method->code_size();
2210 bcp = code_base + bci;
2211 c = (Bytecodes::Code)(*bcp);
2212 bc_length = Bytecodes::length_for(c);
2213 assert(bc_length != 0, "sanity check");
2214 } // end we need ldc_w instead of ldc
2215 } // end if there is a mapped index
2216 } break;
2217
2218 // these bytecodes have a two-byte constant pool index
2219 case Bytecodes::_anewarray : // fall through
2220 case Bytecodes::_checkcast : // fall through
2221 case Bytecodes::_getfield : // fall through
2222 case Bytecodes::_getstatic : // fall through
2223 case Bytecodes::_instanceof : // fall through
2224 case Bytecodes::_invokedynamic : // fall through
2225 case Bytecodes::_invokeinterface: // fall through
2226 case Bytecodes::_invokespecial : // fall through
2227 case Bytecodes::_invokestatic : // fall through
2228 case Bytecodes::_invokevirtual : // fall through
2229 case Bytecodes::_ldc_w : // fall through
2230 case Bytecodes::_ldc2_w : // fall through
2231 case Bytecodes::_multianewarray : // fall through
2232 case Bytecodes::_new : // fall through
2233 case Bytecodes::_putfield : // fall through
2234 case Bytecodes::_putstatic :
2235 {
2236 address p = bcp + 1;
2237 int cp_index = Bytes::get_Java_u2(p);
2238 u2 new_index = find_new_index(cp_index);
2239 if (new_index != 0) {
2240 // the original index is mapped so update w/ new value
2241 log_trace(redefine, class, constantpool)
2242 ("%s@" INTPTR_FORMAT " old=%d, new=%d", Bytecodes::name(c),p2i(bcp), cp_index, new_index);
2243 // Rewriter::rewrite_method() uses put_native_u2() in this
2244 // situation because it is reusing the constant pool index
2245 // location for a native index into the ConstantPoolCache.
2246 // Since we are updating the constant pool index prior to
2247 // verification and ConstantPoolCache initialization, we
2248 // need to keep the new index in Java byte order.
2249 Bytes::put_Java_u2(p, new_index);
2250 }
2251 } break;
2252 default:
2253 break;
2254 }
2255 } // end for each bytecode
2256 } // end rewrite_cp_refs_in_method()
2257
2258
2259 // Rewrite constant pool references in the class_annotations field.
2260 bool VM_RedefineClasses::rewrite_cp_refs_in_class_annotations(InstanceKlass* scratch_class) {
2261
2262 AnnotationArray* class_annotations = scratch_class->class_annotations();
2263 if (class_annotations == nullptr || class_annotations->length() == 0) {
2264 // no class_annotations so nothing to do
2265 return true;
2266 }
2267
2268 log_debug(redefine, class, annotation)("class_annotations length=%d", class_annotations->length());
2269
2270 int byte_i = 0; // byte index into class_annotations
2271 return rewrite_cp_refs_in_annotations_typeArray(class_annotations, byte_i);
2272 }
2273
2274
2275 // Rewrite constant pool references in an annotations typeArray. This
2276 // "structure" is adapted from the RuntimeVisibleAnnotations_attribute
2277 // that is described in section 4.8.15 of the 2nd-edition of the VM spec:
2278 //
2279 // annotations_typeArray {
2280 // u2 num_annotations;
2281 // annotation annotations[num_annotations];
2282 // }
2283 //
2284 bool VM_RedefineClasses::rewrite_cp_refs_in_annotations_typeArray(
2285 AnnotationArray* annotations_typeArray, int &byte_i_ref) {
2286
2287 if ((byte_i_ref + 2) > annotations_typeArray->length()) {
2288 // not enough room for num_annotations field
2289 log_debug(redefine, class, annotation)("length() is too small for num_annotations field");
2290 return false;
2291 }
2292
2293 u2 num_annotations = Bytes::get_Java_u2((address)
2294 annotations_typeArray->adr_at(byte_i_ref));
2295 byte_i_ref += 2;
2296
2297 log_debug(redefine, class, annotation)("num_annotations=%d", num_annotations);
2298
2299 int calc_num_annotations = 0;
2300 for (; calc_num_annotations < num_annotations; calc_num_annotations++) {
2301 if (!rewrite_cp_refs_in_annotation_struct(annotations_typeArray, byte_i_ref)) {
2302 log_debug(redefine, class, annotation)("bad annotation_struct at %d", calc_num_annotations);
2303 // propagate failure back to caller
2304 return false;
2305 }
2306 }
2307 assert(num_annotations == calc_num_annotations, "sanity check");
2308
2309 return true;
2310 } // end rewrite_cp_refs_in_annotations_typeArray()
2311
2312
2313 // Rewrite constant pool references in the annotation struct portion of
2314 // an annotations_typeArray. This "structure" is from section 4.8.15 of
2315 // the 2nd-edition of the VM spec:
2316 //
2317 // struct annotation {
2318 // u2 type_index;
2319 // u2 num_element_value_pairs;
2320 // {
2321 // u2 element_name_index;
2322 // element_value value;
2323 // } element_value_pairs[num_element_value_pairs];
2324 // }
2325 //
2326 bool VM_RedefineClasses::rewrite_cp_refs_in_annotation_struct(
2327 AnnotationArray* annotations_typeArray, int &byte_i_ref) {
2328 if ((byte_i_ref + 2 + 2) > annotations_typeArray->length()) {
2329 // not enough room for smallest annotation_struct
2330 log_debug(redefine, class, annotation)("length() is too small for annotation_struct");
2331 return false;
2332 }
2333
2334 u2 type_index = rewrite_cp_ref_in_annotation_data(annotations_typeArray,
2335 byte_i_ref, "type_index");
2336
2337 u2 num_element_value_pairs = Bytes::get_Java_u2((address)
2338 annotations_typeArray->adr_at(byte_i_ref));
2339 byte_i_ref += 2;
2340
2341 log_debug(redefine, class, annotation)
2342 ("type_index=%d num_element_value_pairs=%d", type_index, num_element_value_pairs);
2343
2344 int calc_num_element_value_pairs = 0;
2345 for (; calc_num_element_value_pairs < num_element_value_pairs;
2346 calc_num_element_value_pairs++) {
2347 if ((byte_i_ref + 2) > annotations_typeArray->length()) {
2348 // not enough room for another element_name_index, let alone
2349 // the rest of another component
2350 log_debug(redefine, class, annotation)("length() is too small for element_name_index");
2351 return false;
2352 }
2353
2354 u2 element_name_index = rewrite_cp_ref_in_annotation_data(
2355 annotations_typeArray, byte_i_ref,
2356 "element_name_index");
2357
2358 log_debug(redefine, class, annotation)("element_name_index=%d", element_name_index);
2359
2360 if (!rewrite_cp_refs_in_element_value(annotations_typeArray, byte_i_ref)) {
2361 log_debug(redefine, class, annotation)("bad element_value at %d", calc_num_element_value_pairs);
2362 // propagate failure back to caller
2363 return false;
2364 }
2365 } // end for each component
2366 assert(num_element_value_pairs == calc_num_element_value_pairs,
2367 "sanity check");
2368
2369 return true;
2370 } // end rewrite_cp_refs_in_annotation_struct()
2371
2372
2373 // Rewrite a constant pool reference at the current position in
2374 // annotations_typeArray if needed. Returns the original constant
2375 // pool reference if a rewrite was not needed or the new constant
2376 // pool reference if a rewrite was needed.
2377 u2 VM_RedefineClasses::rewrite_cp_ref_in_annotation_data(
2378 AnnotationArray* annotations_typeArray, int &byte_i_ref,
2379 const char * trace_mesg) {
2380
2381 address cp_index_addr = (address)
2382 annotations_typeArray->adr_at(byte_i_ref);
2383 u2 old_cp_index = Bytes::get_Java_u2(cp_index_addr);
2384 u2 new_cp_index = find_new_index(old_cp_index);
2385 if (new_cp_index != 0) {
2386 log_debug(redefine, class, annotation)("mapped old %s=%d", trace_mesg, old_cp_index);
2387 Bytes::put_Java_u2(cp_index_addr, new_cp_index);
2388 old_cp_index = new_cp_index;
2389 }
2390 byte_i_ref += 2;
2391 return old_cp_index;
2392 }
2393
2394
2395 // Rewrite constant pool references in the element_value portion of an
2396 // annotations_typeArray. This "structure" is from section 4.8.15.1 of
2397 // the 2nd-edition of the VM spec:
2398 //
2399 // struct element_value {
2400 // u1 tag;
2401 // union {
2402 // u2 const_value_index;
2403 // {
2404 // u2 type_name_index;
2405 // u2 const_name_index;
2406 // } enum_const_value;
2407 // u2 class_info_index;
2408 // annotation annotation_value;
2409 // struct {
2410 // u2 num_values;
2411 // element_value values[num_values];
2412 // } array_value;
2413 // } value;
2414 // }
2415 //
2416 bool VM_RedefineClasses::rewrite_cp_refs_in_element_value(
2417 AnnotationArray* annotations_typeArray, int &byte_i_ref) {
2418
2419 if ((byte_i_ref + 1) > annotations_typeArray->length()) {
2420 // not enough room for a tag let alone the rest of an element_value
2421 log_debug(redefine, class, annotation)("length() is too small for a tag");
2422 return false;
2423 }
2424
2425 u1 tag = annotations_typeArray->at(byte_i_ref);
2426 byte_i_ref++;
2427 log_debug(redefine, class, annotation)("tag='%c'", tag);
2428
2429 switch (tag) {
2430 // These BaseType tag values are from Table 4.2 in VM spec:
2431 case JVM_SIGNATURE_BYTE:
2432 case JVM_SIGNATURE_CHAR:
2433 case JVM_SIGNATURE_DOUBLE:
2434 case JVM_SIGNATURE_FLOAT:
2435 case JVM_SIGNATURE_INT:
2436 case JVM_SIGNATURE_LONG:
2437 case JVM_SIGNATURE_SHORT:
2438 case JVM_SIGNATURE_BOOLEAN:
2439
2440 // The remaining tag values are from Table 4.8 in the 2nd-edition of
2441 // the VM spec:
2442 case 's':
2443 {
2444 // For the above tag values (including the BaseType values),
2445 // value.const_value_index is right union field.
2446
2447 if ((byte_i_ref + 2) > annotations_typeArray->length()) {
2448 // not enough room for a const_value_index
2449 log_debug(redefine, class, annotation)("length() is too small for a const_value_index");
2450 return false;
2451 }
2452
2453 u2 const_value_index = rewrite_cp_ref_in_annotation_data(
2454 annotations_typeArray, byte_i_ref,
2455 "const_value_index");
2456
2457 log_debug(redefine, class, annotation)("const_value_index=%d", const_value_index);
2458 } break;
2459
2460 case 'e':
2461 {
2462 // for the above tag value, value.enum_const_value is right union field
2463
2464 if ((byte_i_ref + 4) > annotations_typeArray->length()) {
2465 // not enough room for a enum_const_value
2466 log_debug(redefine, class, annotation)("length() is too small for a enum_const_value");
2467 return false;
2468 }
2469
2470 u2 type_name_index = rewrite_cp_ref_in_annotation_data(
2471 annotations_typeArray, byte_i_ref,
2472 "type_name_index");
2473
2474 u2 const_name_index = rewrite_cp_ref_in_annotation_data(
2475 annotations_typeArray, byte_i_ref,
2476 "const_name_index");
2477
2478 log_debug(redefine, class, annotation)
2479 ("type_name_index=%d const_name_index=%d", type_name_index, const_name_index);
2480 } break;
2481
2482 case 'c':
2483 {
2484 // for the above tag value, value.class_info_index is right union field
2485
2486 if ((byte_i_ref + 2) > annotations_typeArray->length()) {
2487 // not enough room for a class_info_index
2488 log_debug(redefine, class, annotation)("length() is too small for a class_info_index");
2489 return false;
2490 }
2491
2492 u2 class_info_index = rewrite_cp_ref_in_annotation_data(
2493 annotations_typeArray, byte_i_ref,
2494 "class_info_index");
2495
2496 log_debug(redefine, class, annotation)("class_info_index=%d", class_info_index);
2497 } break;
2498
2499 case '@':
2500 // For the above tag value, value.attr_value is the right union
2501 // field. This is a nested annotation.
2502 if (!rewrite_cp_refs_in_annotation_struct(annotations_typeArray, byte_i_ref)) {
2503 // propagate failure back to caller
2504 return false;
2505 }
2506 break;
2507
2508 case JVM_SIGNATURE_ARRAY:
2509 {
2510 if ((byte_i_ref + 2) > annotations_typeArray->length()) {
2511 // not enough room for a num_values field
2512 log_debug(redefine, class, annotation)("length() is too small for a num_values field");
2513 return false;
2514 }
2515
2516 // For the above tag value, value.array_value is the right union
2517 // field. This is an array of nested element_value.
2518 u2 num_values = Bytes::get_Java_u2((address)
2519 annotations_typeArray->adr_at(byte_i_ref));
2520 byte_i_ref += 2;
2521 log_debug(redefine, class, annotation)("num_values=%d", num_values);
2522
2523 int calc_num_values = 0;
2524 for (; calc_num_values < num_values; calc_num_values++) {
2525 if (!rewrite_cp_refs_in_element_value(annotations_typeArray, byte_i_ref)) {
2526 log_debug(redefine, class, annotation)("bad nested element_value at %d", calc_num_values);
2527 // propagate failure back to caller
2528 return false;
2529 }
2530 }
2531 assert(num_values == calc_num_values, "sanity check");
2532 } break;
2533
2534 default:
2535 log_debug(redefine, class, annotation)("bad tag=0x%x", tag);
2536 return false;
2537 } // end decode tag field
2538
2539 return true;
2540 } // end rewrite_cp_refs_in_element_value()
2541
2542
2543 // Rewrite constant pool references in a fields_annotations field.
2544 bool VM_RedefineClasses::rewrite_cp_refs_in_fields_annotations(
2545 InstanceKlass* scratch_class) {
2546
2547 Array<AnnotationArray*>* fields_annotations = scratch_class->fields_annotations();
2548
2549 if (fields_annotations == nullptr || fields_annotations->length() == 0) {
2550 // no fields_annotations so nothing to do
2551 return true;
2552 }
2553
2554 log_debug(redefine, class, annotation)("fields_annotations length=%d", fields_annotations->length());
2555
2556 for (int i = 0; i < fields_annotations->length(); i++) {
2557 AnnotationArray* field_annotations = fields_annotations->at(i);
2558 if (field_annotations == nullptr || field_annotations->length() == 0) {
2559 // this field does not have any annotations so skip it
2560 continue;
2561 }
2562
2563 int byte_i = 0; // byte index into field_annotations
2564 if (!rewrite_cp_refs_in_annotations_typeArray(field_annotations, byte_i)) {
2565 log_debug(redefine, class, annotation)("bad field_annotations at %d", i);
2566 // propagate failure back to caller
2567 return false;
2568 }
2569 }
2570
2571 return true;
2572 } // end rewrite_cp_refs_in_fields_annotations()
2573
2574
2575 // Rewrite constant pool references in a methods_annotations field.
2576 bool VM_RedefineClasses::rewrite_cp_refs_in_methods_annotations(
2577 InstanceKlass* scratch_class) {
2578
2579 for (int i = 0; i < scratch_class->methods()->length(); i++) {
2580 Method* m = scratch_class->methods()->at(i);
2581 AnnotationArray* method_annotations = m->constMethod()->method_annotations();
2582
2583 if (method_annotations == nullptr || method_annotations->length() == 0) {
2584 // this method does not have any annotations so skip it
2585 continue;
2586 }
2587
2588 int byte_i = 0; // byte index into method_annotations
2589 if (!rewrite_cp_refs_in_annotations_typeArray(method_annotations, byte_i)) {
2590 log_debug(redefine, class, annotation)("bad method_annotations at %d", i);
2591 // propagate failure back to caller
2592 return false;
2593 }
2594 }
2595
2596 return true;
2597 } // end rewrite_cp_refs_in_methods_annotations()
2598
2599
2600 // Rewrite constant pool references in a methods_parameter_annotations
2601 // field. This "structure" is adapted from the
2602 // RuntimeVisibleParameterAnnotations_attribute described in section
2603 // 4.8.17 of the 2nd-edition of the VM spec:
2604 //
2605 // methods_parameter_annotations_typeArray {
2606 // u1 num_parameters;
2607 // {
2608 // u2 num_annotations;
2609 // annotation annotations[num_annotations];
2610 // } parameter_annotations[num_parameters];
2611 // }
2612 //
2613 bool VM_RedefineClasses::rewrite_cp_refs_in_methods_parameter_annotations(
2614 InstanceKlass* scratch_class) {
2615
2616 for (int i = 0; i < scratch_class->methods()->length(); i++) {
2617 Method* m = scratch_class->methods()->at(i);
2618 AnnotationArray* method_parameter_annotations = m->constMethod()->parameter_annotations();
2619 if (method_parameter_annotations == nullptr
2620 || method_parameter_annotations->length() == 0) {
2621 // this method does not have any parameter annotations so skip it
2622 continue;
2623 }
2624
2625 if (method_parameter_annotations->length() < 1) {
2626 // not enough room for a num_parameters field
2627 log_debug(redefine, class, annotation)("length() is too small for a num_parameters field at %d", i);
2628 return false;
2629 }
2630
2631 int byte_i = 0; // byte index into method_parameter_annotations
2632
2633 u1 num_parameters = method_parameter_annotations->at(byte_i);
2634 byte_i++;
2635
2636 log_debug(redefine, class, annotation)("num_parameters=%d", num_parameters);
2637
2638 int calc_num_parameters = 0;
2639 for (; calc_num_parameters < num_parameters; calc_num_parameters++) {
2640 if (!rewrite_cp_refs_in_annotations_typeArray(method_parameter_annotations, byte_i)) {
2641 log_debug(redefine, class, annotation)("bad method_parameter_annotations at %d", calc_num_parameters);
2642 // propagate failure back to caller
2643 return false;
2644 }
2645 }
2646 assert(num_parameters == calc_num_parameters, "sanity check");
2647 }
2648
2649 return true;
2650 } // end rewrite_cp_refs_in_methods_parameter_annotations()
2651
2652
2653 // Rewrite constant pool references in a methods_default_annotations
2654 // field. This "structure" is adapted from the AnnotationDefault_attribute
2655 // that is described in section 4.8.19 of the 2nd-edition of the VM spec:
2656 //
2657 // methods_default_annotations_typeArray {
2658 // element_value default_value;
2659 // }
2660 //
2661 bool VM_RedefineClasses::rewrite_cp_refs_in_methods_default_annotations(
2662 InstanceKlass* scratch_class) {
2663
2664 for (int i = 0; i < scratch_class->methods()->length(); i++) {
2665 Method* m = scratch_class->methods()->at(i);
2666 AnnotationArray* method_default_annotations = m->constMethod()->default_annotations();
2667 if (method_default_annotations == nullptr
2668 || method_default_annotations->length() == 0) {
2669 // this method does not have any default annotations so skip it
2670 continue;
2671 }
2672
2673 int byte_i = 0; // byte index into method_default_annotations
2674
2675 if (!rewrite_cp_refs_in_element_value(
2676 method_default_annotations, byte_i)) {
2677 log_debug(redefine, class, annotation)("bad default element_value at %d", i);
2678 // propagate failure back to caller
2679 return false;
2680 }
2681 }
2682
2683 return true;
2684 } // end rewrite_cp_refs_in_methods_default_annotations()
2685
2686
2687 // Rewrite constant pool references in a class_type_annotations field.
2688 bool VM_RedefineClasses::rewrite_cp_refs_in_class_type_annotations(
2689 InstanceKlass* scratch_class) {
2690
2691 AnnotationArray* class_type_annotations = scratch_class->class_type_annotations();
2692 if (class_type_annotations == nullptr || class_type_annotations->length() == 0) {
2693 // no class_type_annotations so nothing to do
2694 return true;
2695 }
2696
2697 log_debug(redefine, class, annotation)("class_type_annotations length=%d", class_type_annotations->length());
2698
2699 int byte_i = 0; // byte index into class_type_annotations
2700 return rewrite_cp_refs_in_type_annotations_typeArray(class_type_annotations,
2701 byte_i, "ClassFile");
2702 } // end rewrite_cp_refs_in_class_type_annotations()
2703
2704
2705 // Rewrite constant pool references in a fields_type_annotations field.
2706 bool VM_RedefineClasses::rewrite_cp_refs_in_fields_type_annotations(InstanceKlass* scratch_class) {
2707
2708 Array<AnnotationArray*>* fields_type_annotations = scratch_class->fields_type_annotations();
2709 if (fields_type_annotations == nullptr || fields_type_annotations->length() == 0) {
2710 // no fields_type_annotations so nothing to do
2711 return true;
2712 }
2713
2714 log_debug(redefine, class, annotation)("fields_type_annotations length=%d", fields_type_annotations->length());
2715
2716 for (int i = 0; i < fields_type_annotations->length(); i++) {
2717 AnnotationArray* field_type_annotations = fields_type_annotations->at(i);
2718 if (field_type_annotations == nullptr || field_type_annotations->length() == 0) {
2719 // this field does not have any annotations so skip it
2720 continue;
2721 }
2722
2723 int byte_i = 0; // byte index into field_type_annotations
2724 if (!rewrite_cp_refs_in_type_annotations_typeArray(field_type_annotations,
2725 byte_i, "field_info")) {
2726 log_debug(redefine, class, annotation)("bad field_type_annotations at %d", i);
2727 // propagate failure back to caller
2728 return false;
2729 }
2730 }
2731
2732 return true;
2733 } // end rewrite_cp_refs_in_fields_type_annotations()
2734
2735
2736 // Rewrite constant pool references in a methods_type_annotations field.
2737 bool VM_RedefineClasses::rewrite_cp_refs_in_methods_type_annotations(
2738 InstanceKlass* scratch_class) {
2739
2740 for (int i = 0; i < scratch_class->methods()->length(); i++) {
2741 Method* m = scratch_class->methods()->at(i);
2742 AnnotationArray* method_type_annotations = m->constMethod()->type_annotations();
2743
2744 if (method_type_annotations == nullptr || method_type_annotations->length() == 0) {
2745 // this method does not have any annotations so skip it
2746 continue;
2747 }
2748
2749 log_debug(redefine, class, annotation)("methods type_annotations length=%d", method_type_annotations->length());
2750
2751 int byte_i = 0; // byte index into method_type_annotations
2752 if (!rewrite_cp_refs_in_type_annotations_typeArray(method_type_annotations,
2753 byte_i, "method_info")) {
2754 log_debug(redefine, class, annotation)("bad method_type_annotations at %d", i);
2755 // propagate failure back to caller
2756 return false;
2757 }
2758 }
2759
2760 return true;
2761 } // end rewrite_cp_refs_in_methods_type_annotations()
2762
2763
2764 // Rewrite constant pool references in a type_annotations
2765 // field. This "structure" is adapted from the
2766 // RuntimeVisibleTypeAnnotations_attribute described in
2767 // section 4.7.20 of the Java SE 8 Edition of the VM spec:
2768 //
2769 // type_annotations_typeArray {
2770 // u2 num_annotations;
2771 // type_annotation annotations[num_annotations];
2772 // }
2773 //
2774 bool VM_RedefineClasses::rewrite_cp_refs_in_type_annotations_typeArray(
2775 AnnotationArray* type_annotations_typeArray, int &byte_i_ref,
2776 const char * location_mesg) {
2777
2778 if ((byte_i_ref + 2) > type_annotations_typeArray->length()) {
2779 // not enough room for num_annotations field
2780 log_debug(redefine, class, annotation)("length() is too small for num_annotations field");
2781 return false;
2782 }
2783
2784 u2 num_annotations = Bytes::get_Java_u2((address)
2785 type_annotations_typeArray->adr_at(byte_i_ref));
2786 byte_i_ref += 2;
2787
2788 log_debug(redefine, class, annotation)("num_type_annotations=%d", num_annotations);
2789
2790 int calc_num_annotations = 0;
2791 for (; calc_num_annotations < num_annotations; calc_num_annotations++) {
2792 if (!rewrite_cp_refs_in_type_annotation_struct(type_annotations_typeArray,
2793 byte_i_ref, location_mesg)) {
2794 log_debug(redefine, class, annotation)("bad type_annotation_struct at %d", calc_num_annotations);
2795 // propagate failure back to caller
2796 return false;
2797 }
2798 }
2799 assert(num_annotations == calc_num_annotations, "sanity check");
2800
2801 if (byte_i_ref != type_annotations_typeArray->length()) {
2802 log_debug(redefine, class, annotation)
2803 ("read wrong amount of bytes at end of processing type_annotations_typeArray (%d of %d bytes were read)",
2804 byte_i_ref, type_annotations_typeArray->length());
2805 return false;
2806 }
2807
2808 return true;
2809 } // end rewrite_cp_refs_in_type_annotations_typeArray()
2810
2811
2812 // Rewrite constant pool references in a type_annotation
2813 // field. This "structure" is adapted from the
2814 // RuntimeVisibleTypeAnnotations_attribute described in
2815 // section 4.7.20 of the Java SE 8 Edition of the VM spec:
2816 //
2817 // type_annotation {
2818 // u1 target_type;
2819 // union {
2820 // type_parameter_target;
2821 // supertype_target;
2822 // type_parameter_bound_target;
2823 // empty_target;
2824 // method_formal_parameter_target;
2825 // throws_target;
2826 // localvar_target;
2827 // catch_target;
2828 // offset_target;
2829 // type_argument_target;
2830 // } target_info;
2831 // type_path target_path;
2832 // annotation anno;
2833 // }
2834 //
2835 bool VM_RedefineClasses::rewrite_cp_refs_in_type_annotation_struct(
2836 AnnotationArray* type_annotations_typeArray, int &byte_i_ref,
2837 const char * location_mesg) {
2838
2839 if (!skip_type_annotation_target(type_annotations_typeArray,
2840 byte_i_ref, location_mesg)) {
2841 return false;
2842 }
2843
2844 if (!skip_type_annotation_type_path(type_annotations_typeArray, byte_i_ref)) {
2845 return false;
2846 }
2847
2848 if (!rewrite_cp_refs_in_annotation_struct(type_annotations_typeArray, byte_i_ref)) {
2849 return false;
2850 }
2851
2852 return true;
2853 } // end rewrite_cp_refs_in_type_annotation_struct()
2854
2855
2856 // Read, verify and skip over the target_type and target_info part
2857 // so that rewriting can continue in the later parts of the struct.
2858 //
2859 // u1 target_type;
2860 // union {
2861 // type_parameter_target;
2862 // supertype_target;
2863 // type_parameter_bound_target;
2864 // empty_target;
2865 // method_formal_parameter_target;
2866 // throws_target;
2867 // localvar_target;
2868 // catch_target;
2869 // offset_target;
2870 // type_argument_target;
2871 // } target_info;
2872 //
2873 bool VM_RedefineClasses::skip_type_annotation_target(
2874 AnnotationArray* type_annotations_typeArray, int &byte_i_ref,
2875 const char * location_mesg) {
2876
2877 if ((byte_i_ref + 1) > type_annotations_typeArray->length()) {
2878 // not enough room for a target_type let alone the rest of a type_annotation
2879 log_debug(redefine, class, annotation)("length() is too small for a target_type");
2880 return false;
2881 }
2882
2883 u1 target_type = type_annotations_typeArray->at(byte_i_ref);
2884 byte_i_ref += 1;
2885 log_debug(redefine, class, annotation)("target_type=0x%.2x", target_type);
2886 log_debug(redefine, class, annotation)("location=%s", location_mesg);
2887
2888 // Skip over target_info
2889 switch (target_type) {
2890 case 0x00:
2891 // kind: type parameter declaration of generic class or interface
2892 // location: ClassFile
2893 case 0x01:
2894 // kind: type parameter declaration of generic method or constructor
2895 // location: method_info
2896
2897 {
2898 // struct:
2899 // type_parameter_target {
2900 // u1 type_parameter_index;
2901 // }
2902 //
2903 if ((byte_i_ref + 1) > type_annotations_typeArray->length()) {
2904 log_debug(redefine, class, annotation)("length() is too small for a type_parameter_target");
2905 return false;
2906 }
2907
2908 u1 type_parameter_index = type_annotations_typeArray->at(byte_i_ref);
2909 byte_i_ref += 1;
2910
2911 log_debug(redefine, class, annotation)("type_parameter_target: type_parameter_index=%d", type_parameter_index);
2912 } break;
2913
2914 case 0x10:
2915 // kind: type in extends clause of class or interface declaration
2916 // or in implements clause of interface declaration
2917 // location: ClassFile
2918
2919 {
2920 // struct:
2921 // supertype_target {
2922 // u2 supertype_index;
2923 // }
2924 //
2925 if ((byte_i_ref + 2) > type_annotations_typeArray->length()) {
2926 log_debug(redefine, class, annotation)("length() is too small for a supertype_target");
2927 return false;
2928 }
2929
2930 u2 supertype_index = Bytes::get_Java_u2((address)
2931 type_annotations_typeArray->adr_at(byte_i_ref));
2932 byte_i_ref += 2;
2933
2934 log_debug(redefine, class, annotation)("supertype_target: supertype_index=%d", supertype_index);
2935 } break;
2936
2937 case 0x11:
2938 // kind: type in bound of type parameter declaration of generic class or interface
2939 // location: ClassFile
2940 case 0x12:
2941 // kind: type in bound of type parameter declaration of generic method or constructor
2942 // location: method_info
2943
2944 {
2945 // struct:
2946 // type_parameter_bound_target {
2947 // u1 type_parameter_index;
2948 // u1 bound_index;
2949 // }
2950 //
2951 if ((byte_i_ref + 2) > type_annotations_typeArray->length()) {
2952 log_debug(redefine, class, annotation)("length() is too small for a type_parameter_bound_target");
2953 return false;
2954 }
2955
2956 u1 type_parameter_index = type_annotations_typeArray->at(byte_i_ref);
2957 byte_i_ref += 1;
2958 u1 bound_index = type_annotations_typeArray->at(byte_i_ref);
2959 byte_i_ref += 1;
2960
2961 log_debug(redefine, class, annotation)
2962 ("type_parameter_bound_target: type_parameter_index=%d, bound_index=%d", type_parameter_index, bound_index);
2963 } break;
2964
2965 case 0x13:
2966 // kind: type in field declaration
2967 // location: field_info
2968 case 0x14:
2969 // kind: return type of method, or type of newly constructed object
2970 // location: method_info
2971 case 0x15:
2972 // kind: receiver type of method or constructor
2973 // location: method_info
2974
2975 {
2976 // struct:
2977 // empty_target {
2978 // }
2979 //
2980 log_debug(redefine, class, annotation)("empty_target");
2981 } break;
2982
2983 case 0x16:
2984 // kind: type in formal parameter declaration of method, constructor, or lambda expression
2985 // location: method_info
2986
2987 {
2988 // struct:
2989 // formal_parameter_target {
2990 // u1 formal_parameter_index;
2991 // }
2992 //
2993 if ((byte_i_ref + 1) > type_annotations_typeArray->length()) {
2994 log_debug(redefine, class, annotation)("length() is too small for a formal_parameter_target");
2995 return false;
2996 }
2997
2998 u1 formal_parameter_index = type_annotations_typeArray->at(byte_i_ref);
2999 byte_i_ref += 1;
3000
3001 log_debug(redefine, class, annotation)
3002 ("formal_parameter_target: formal_parameter_index=%d", formal_parameter_index);
3003 } break;
3004
3005 case 0x17:
3006 // kind: type in throws clause of method or constructor
3007 // location: method_info
3008
3009 {
3010 // struct:
3011 // throws_target {
3012 // u2 throws_type_index
3013 // }
3014 //
3015 if ((byte_i_ref + 2) > type_annotations_typeArray->length()) {
3016 log_debug(redefine, class, annotation)("length() is too small for a throws_target");
3017 return false;
3018 }
3019
3020 u2 throws_type_index = Bytes::get_Java_u2((address)
3021 type_annotations_typeArray->adr_at(byte_i_ref));
3022 byte_i_ref += 2;
3023
3024 log_debug(redefine, class, annotation)("throws_target: throws_type_index=%d", throws_type_index);
3025 } break;
3026
3027 case 0x40:
3028 // kind: type in local variable declaration
3029 // location: Code
3030 case 0x41:
3031 // kind: type in resource variable declaration
3032 // location: Code
3033
3034 {
3035 // struct:
3036 // localvar_target {
3037 // u2 table_length;
3038 // struct {
3039 // u2 start_pc;
3040 // u2 length;
3041 // u2 index;
3042 // } table[table_length];
3043 // }
3044 //
3045 if ((byte_i_ref + 2) > type_annotations_typeArray->length()) {
3046 // not enough room for a table_length let alone the rest of a localvar_target
3047 log_debug(redefine, class, annotation)("length() is too small for a localvar_target table_length");
3048 return false;
3049 }
3050
3051 u2 table_length = Bytes::get_Java_u2((address)
3052 type_annotations_typeArray->adr_at(byte_i_ref));
3053 byte_i_ref += 2;
3054
3055 log_debug(redefine, class, annotation)("localvar_target: table_length=%d", table_length);
3056
3057 int table_struct_size = 2 + 2 + 2; // 3 u2 variables per table entry
3058 int table_size = table_length * table_struct_size;
3059
3060 if ((byte_i_ref + table_size) > type_annotations_typeArray->length()) {
3061 // not enough room for a table
3062 log_debug(redefine, class, annotation)("length() is too small for a table array of length %d", table_length);
3063 return false;
3064 }
3065
3066 // Skip over table
3067 byte_i_ref += table_size;
3068 } break;
3069
3070 case 0x42:
3071 // kind: type in exception parameter declaration
3072 // location: Code
3073
3074 {
3075 // struct:
3076 // catch_target {
3077 // u2 exception_table_index;
3078 // }
3079 //
3080 if ((byte_i_ref + 2) > type_annotations_typeArray->length()) {
3081 log_debug(redefine, class, annotation)("length() is too small for a catch_target");
3082 return false;
3083 }
3084
3085 u2 exception_table_index = Bytes::get_Java_u2((address)
3086 type_annotations_typeArray->adr_at(byte_i_ref));
3087 byte_i_ref += 2;
3088
3089 log_debug(redefine, class, annotation)("catch_target: exception_table_index=%d", exception_table_index);
3090 } break;
3091
3092 case 0x43:
3093 // kind: type in instanceof expression
3094 // location: Code
3095 case 0x44:
3096 // kind: type in new expression
3097 // location: Code
3098 case 0x45:
3099 // kind: type in method reference expression using ::new
3100 // location: Code
3101 case 0x46:
3102 // kind: type in method reference expression using ::Identifier
3103 // location: Code
3104
3105 {
3106 // struct:
3107 // offset_target {
3108 // u2 offset;
3109 // }
3110 //
3111 if ((byte_i_ref + 2) > type_annotations_typeArray->length()) {
3112 log_debug(redefine, class, annotation)("length() is too small for a offset_target");
3113 return false;
3114 }
3115
3116 u2 offset = Bytes::get_Java_u2((address)
3117 type_annotations_typeArray->adr_at(byte_i_ref));
3118 byte_i_ref += 2;
3119
3120 log_debug(redefine, class, annotation)("offset_target: offset=%d", offset);
3121 } break;
3122
3123 case 0x47:
3124 // kind: type in cast expression
3125 // location: Code
3126 case 0x48:
3127 // kind: type argument for generic constructor in new expression or
3128 // explicit constructor invocation statement
3129 // location: Code
3130 case 0x49:
3131 // kind: type argument for generic method in method invocation expression
3132 // location: Code
3133 case 0x4A:
3134 // kind: type argument for generic constructor in method reference expression using ::new
3135 // location: Code
3136 case 0x4B:
3137 // kind: type argument for generic method in method reference expression using ::Identifier
3138 // location: Code
3139
3140 {
3141 // struct:
3142 // type_argument_target {
3143 // u2 offset;
3144 // u1 type_argument_index;
3145 // }
3146 //
3147 if ((byte_i_ref + 3) > type_annotations_typeArray->length()) {
3148 log_debug(redefine, class, annotation)("length() is too small for a type_argument_target");
3149 return false;
3150 }
3151
3152 u2 offset = Bytes::get_Java_u2((address)
3153 type_annotations_typeArray->adr_at(byte_i_ref));
3154 byte_i_ref += 2;
3155 u1 type_argument_index = type_annotations_typeArray->at(byte_i_ref);
3156 byte_i_ref += 1;
3157
3158 log_debug(redefine, class, annotation)
3159 ("type_argument_target: offset=%d, type_argument_index=%d", offset, type_argument_index);
3160 } break;
3161
3162 default:
3163 log_debug(redefine, class, annotation)("unknown target_type");
3164 #ifdef ASSERT
3165 ShouldNotReachHere();
3166 #endif
3167 return false;
3168 }
3169
3170 return true;
3171 } // end skip_type_annotation_target()
3172
3173
3174 // Read, verify and skip over the type_path part so that rewriting
3175 // can continue in the later parts of the struct.
3176 //
3177 // type_path {
3178 // u1 path_length;
3179 // {
3180 // u1 type_path_kind;
3181 // u1 type_argument_index;
3182 // } path[path_length];
3183 // }
3184 //
3185 bool VM_RedefineClasses::skip_type_annotation_type_path(
3186 AnnotationArray* type_annotations_typeArray, int &byte_i_ref) {
3187
3188 if ((byte_i_ref + 1) > type_annotations_typeArray->length()) {
3189 // not enough room for a path_length let alone the rest of the type_path
3190 log_debug(redefine, class, annotation)("length() is too small for a type_path");
3191 return false;
3192 }
3193
3194 u1 path_length = type_annotations_typeArray->at(byte_i_ref);
3195 byte_i_ref += 1;
3196
3197 log_debug(redefine, class, annotation)("type_path: path_length=%d", path_length);
3198
3199 int calc_path_length = 0;
3200 for (; calc_path_length < path_length; calc_path_length++) {
3201 if ((byte_i_ref + 1 + 1) > type_annotations_typeArray->length()) {
3202 // not enough room for a path
3203 log_debug(redefine, class, annotation)
3204 ("length() is too small for path entry %d of %d", calc_path_length, path_length);
3205 return false;
3206 }
3207
3208 u1 type_path_kind = type_annotations_typeArray->at(byte_i_ref);
3209 byte_i_ref += 1;
3210 u1 type_argument_index = type_annotations_typeArray->at(byte_i_ref);
3211 byte_i_ref += 1;
3212
3213 log_debug(redefine, class, annotation)
3214 ("type_path: path[%d]: type_path_kind=%d, type_argument_index=%d",
3215 calc_path_length, type_path_kind, type_argument_index);
3216
3217 if (type_path_kind > 3 || (type_path_kind != 3 && type_argument_index != 0)) {
3218 // not enough room for a path
3219 log_debug(redefine, class, annotation)("inconsistent type_path values");
3220 return false;
3221 }
3222 }
3223 assert(path_length == calc_path_length, "sanity check");
3224
3225 return true;
3226 } // end skip_type_annotation_type_path()
3227
3228
3229 // Rewrite constant pool references in the method's stackmap table.
3230 // These "structures" are adapted from the StackMapTable_attribute that
3231 // is described in section 4.8.4 of the 6.0 version of the VM spec
3232 // (dated 2005.10.26):
3233 // file:///net/quincunx.sfbay/export/gbracha/ClassFile-Java6.pdf
3234 //
3235 // stack_map {
3236 // u2 number_of_entries;
3237 // stack_map_frame entries[number_of_entries];
3238 // }
3239 //
3240 void VM_RedefineClasses::rewrite_cp_refs_in_stack_map_table(
3241 const methodHandle& method) {
3242
3243 if (!method->has_stackmap_table()) {
3244 return;
3245 }
3246
3247 AnnotationArray* stackmap_data = method->stackmap_data();
3248 address stackmap_p = (address)stackmap_data->adr_at(0);
3249 address stackmap_end = stackmap_p + stackmap_data->length();
3250
3251 assert(stackmap_p + 2 <= stackmap_end, "no room for number_of_entries");
3252 u2 number_of_entries = Bytes::get_Java_u2(stackmap_p);
3253 stackmap_p += 2;
3254
3255 log_debug(redefine, class, stackmap)("number_of_entries=%u", number_of_entries);
3256
3257 // walk through each stack_map_frame
3258 u2 calc_number_of_entries = 0;
3259 for (; calc_number_of_entries < number_of_entries; calc_number_of_entries++) {
3260 // The stack_map_frame structure is a u1 frame_type followed by
3261 // 0 or more bytes of data:
3262 //
3263 // union stack_map_frame {
3264 // same_frame;
3265 // same_locals_1_stack_item_frame;
3266 // same_locals_1_stack_item_frame_extended;
3267 // chop_frame;
3268 // same_frame_extended;
3269 // append_frame;
3270 // full_frame;
3271 // }
3272
3273 assert(stackmap_p + 1 <= stackmap_end, "no room for frame_type");
3274 u1 frame_type = *stackmap_p;
3275 stackmap_p++;
3276
3277 if (frame_type == 246) { // EARLY_LARVAL
3278 // rewrite_cp_refs in unset fields and fall through.
3279 rewrite_cp_refs_in_early_larval_stackmaps(stackmap_p, stackmap_end, calc_number_of_entries, frame_type);
3280 // The larval frames point to the next frame, so advance to the next frame and fall through.
3281 frame_type = *stackmap_p;
3282 stackmap_p++;
3283 }
3284
3285 // same_frame {
3286 // u1 frame_type = SAME; /* 0-63 */
3287 // }
3288 if (frame_type <= StackMapReader::SAME_FRAME_END) {
3289 // nothing more to do for same_frame
3290 }
3291
3292 // same_locals_1_stack_item_frame {
3293 // u1 frame_type = SAME_LOCALS_1_STACK_ITEM; /* 64-127 */
3294 // verification_type_info stack[1];
3295 // }
3296 else if (frame_type >= StackMapReader::SAME_LOCALS_1_STACK_ITEM_FRAME_START &&
3297 frame_type <= StackMapReader::SAME_LOCALS_1_STACK_ITEM_FRAME_END) {
3298 rewrite_cp_refs_in_verification_type_info(stackmap_p, stackmap_end,
3299 calc_number_of_entries, frame_type);
3300 }
3301
3302 // reserved for future use
3303 else if (frame_type >= StackMapReader::RESERVED_START &&
3304 frame_type <= StackMapReader::RESERVED_END) {
3305 // nothing more to do for reserved frame_types
3306 }
3307
3308 // same_locals_1_stack_item_frame_extended {
3309 // u1 frame_type = SAME_LOCALS_1_STACK_ITEM_EXTENDED; /* 247 */
3310 // u2 offset_delta;
3311 // verification_type_info stack[1];
3312 // }
3313 else if (frame_type == StackMapReader::SAME_LOCALS_1_STACK_ITEM_EXTENDED) {
3314 stackmap_p += 2;
3315 rewrite_cp_refs_in_verification_type_info(stackmap_p, stackmap_end,
3316 calc_number_of_entries, frame_type);
3317 }
3318
3319 // chop_frame {
3320 // u1 frame_type = CHOP; /* 248-250 */
3321 // u2 offset_delta;
3322 // }
3323 else if (frame_type >= StackMapReader::CHOP_FRAME_START &&
3324 frame_type <= StackMapReader::CHOP_FRAME_END) {
3325 stackmap_p += 2;
3326 }
3327
3328 // same_frame_extended {
3329 // u1 frame_type = SAME_EXTENDED; /* 251 */
3330 // u2 offset_delta;
3331 // }
3332 else if (frame_type == StackMapReader::SAME_FRAME_EXTENDED) {
3333 stackmap_p += 2;
3334 }
3335
3336 // append_frame {
3337 // u1 frame_type = APPEND; /* 252-254 */
3338 // u2 offset_delta;
3339 // verification_type_info locals[frame_type - SAME_EXTENDED];
3340 // }
3341 else if (frame_type >= StackMapReader::APPEND_FRAME_START &&
3342 frame_type <= StackMapReader::APPEND_FRAME_END) {
3343 assert(stackmap_p + 2 <= stackmap_end,
3344 "no room for offset_delta");
3345 stackmap_p += 2;
3346 u1 len = frame_type - StackMapReader::APPEND_FRAME_START + 1;
3347 for (u1 i = 0; i < len; i++) {
3348 rewrite_cp_refs_in_verification_type_info(stackmap_p, stackmap_end,
3349 calc_number_of_entries, frame_type);
3350 }
3351 }
3352
3353 // full_frame {
3354 // u1 frame_type = FULL_FRAME; /* 255 */
3355 // u2 offset_delta;
3356 // u2 number_of_locals;
3357 // verification_type_info locals[number_of_locals];
3358 // u2 number_of_stack_items;
3359 // verification_type_info stack[number_of_stack_items];
3360 // }
3361 else if (frame_type == StackMapReader::FULL_FRAME) {
3362 assert(stackmap_p + 2 + 2 <= stackmap_end,
3363 "no room for smallest full_frame");
3364 stackmap_p += 2;
3365
3366 u2 number_of_locals = Bytes::get_Java_u2(stackmap_p);
3367 stackmap_p += 2;
3368
3369 for (u2 locals_i = 0; locals_i < number_of_locals; locals_i++) {
3370 rewrite_cp_refs_in_verification_type_info(stackmap_p, stackmap_end,
3371 calc_number_of_entries, frame_type);
3372 }
3373
3374 // Use the largest size for the number_of_stack_items, but only get
3375 // the right number of bytes.
3376 u2 number_of_stack_items = Bytes::get_Java_u2(stackmap_p);
3377 stackmap_p += 2;
3378
3379 for (u2 stack_i = 0; stack_i < number_of_stack_items; stack_i++) {
3380 rewrite_cp_refs_in_verification_type_info(stackmap_p, stackmap_end,
3381 calc_number_of_entries, frame_type);
3382 }
3383 }
3384 } // end while there is a stack_map_frame
3385 assert(number_of_entries == calc_number_of_entries, "sanity check");
3386 } // end rewrite_cp_refs_in_stack_map_table()
3387
3388
3389 // Rewrite constant pool references in the verification type info
3390 // portion of the method's stackmap table. These "structures" are
3391 // adapted from the StackMapTable_attribute that is described in
3392 // section 4.8.4 of the 6.0 version of the VM spec (dated 2005.10.26):
3393 // file:///net/quincunx.sfbay/export/gbracha/ClassFile-Java6.pdf
3394 //
3395 // The verification_type_info structure is a u1 tag followed by 0 or
3396 // more bytes of data:
3397 //
3398 // union verification_type_info {
3399 // Top_variable_info;
3400 // Integer_variable_info;
3401 // Float_variable_info;
3402 // Long_variable_info;
3403 // Double_variable_info;
3404 // Null_variable_info;
3405 // UninitializedThis_variable_info;
3406 // Object_variable_info;
3407 // Uninitialized_variable_info;
3408 // }
3409 //
3410 void VM_RedefineClasses::rewrite_cp_refs_in_verification_type_info(
3411 address& stackmap_p_ref, address stackmap_end, u2 frame_i,
3412 u1 frame_type) {
3413
3414 assert(stackmap_p_ref + 1 <= stackmap_end, "no room for tag");
3415 u1 tag = *stackmap_p_ref;
3416 stackmap_p_ref++;
3417
3418 switch (tag) {
3419 // Top_variable_info {
3420 // u1 tag = ITEM_Top; /* 0 */
3421 // }
3422 // verificationType.hpp has zero as ITEM_Bogus instead of ITEM_Top
3423 case 0: // fall through
3424
3425 // Integer_variable_info {
3426 // u1 tag = ITEM_Integer; /* 1 */
3427 // }
3428 case ITEM_Integer: // fall through
3429
3430 // Float_variable_info {
3431 // u1 tag = ITEM_Float; /* 2 */
3432 // }
3433 case ITEM_Float: // fall through
3434
3435 // Double_variable_info {
3436 // u1 tag = ITEM_Double; /* 3 */
3437 // }
3438 case ITEM_Double: // fall through
3439
3440 // Long_variable_info {
3441 // u1 tag = ITEM_Long; /* 4 */
3442 // }
3443 case ITEM_Long: // fall through
3444
3445 // Null_variable_info {
3446 // u1 tag = ITEM_Null; /* 5 */
3447 // }
3448 case ITEM_Null: // fall through
3449
3450 // UninitializedThis_variable_info {
3451 // u1 tag = ITEM_UninitializedThis; /* 6 */
3452 // }
3453 case ITEM_UninitializedThis:
3454 // nothing more to do for the above tag types
3455 break;
3456
3457 // Object_variable_info {
3458 // u1 tag = ITEM_Object; /* 7 */
3459 // u2 cpool_index;
3460 // }
3461 case ITEM_Object:
3462 {
3463 assert(stackmap_p_ref + 2 <= stackmap_end, "no room for cpool_index");
3464 u2 cpool_index = Bytes::get_Java_u2(stackmap_p_ref);
3465 u2 new_cp_index = find_new_index(cpool_index);
3466 if (new_cp_index != 0) {
3467 log_debug(redefine, class, stackmap)("mapped old cpool_index=%d", cpool_index);
3468 Bytes::put_Java_u2(stackmap_p_ref, new_cp_index);
3469 cpool_index = new_cp_index;
3470 }
3471 stackmap_p_ref += 2;
3472
3473 log_debug(redefine, class, stackmap)
3474 ("frame_i=%u, frame_type=%u, cpool_index=%d", frame_i, frame_type, cpool_index);
3475 } break;
3476
3477 // Uninitialized_variable_info {
3478 // u1 tag = ITEM_Uninitialized; /* 8 */
3479 // u2 offset;
3480 // }
3481 case ITEM_Uninitialized:
3482 assert(stackmap_p_ref + 2 <= stackmap_end, "no room for offset");
3483 stackmap_p_ref += 2;
3484 break;
3485
3486 default:
3487 log_debug(redefine, class, stackmap)("frame_i=%u, frame_type=%u, bad tag=0x%x", frame_i, frame_type, tag);
3488 ShouldNotReachHere();
3489 break;
3490 } // end switch (tag)
3491 } // end rewrite_cp_refs_in_verification_type_info()
3492
3493
3494 void VM_RedefineClasses::rewrite_cp_refs_in_early_larval_stackmaps(
3495 address& stackmap_p_ref, address stackmap_end, u2 frame_i,
3496 u1 frame_type) {
3497
3498 u2 num_early_larval_stackmaps = Bytes::get_Java_u2(stackmap_p_ref);
3499 stackmap_p_ref += 2;
3500
3501 for (u2 i = 0; i < num_early_larval_stackmaps; i++) {
3502
3503 u2 name_and_ref_index = Bytes::get_Java_u2(stackmap_p_ref);
3504 u2 new_cp_index = find_new_index(name_and_ref_index);
3505 if (new_cp_index != 0) {
3506 log_debug(redefine, class, stackmap)("mapped old name_and_ref_index=%d", name_and_ref_index);
3507 Bytes::put_Java_u2(stackmap_p_ref, new_cp_index);
3508 name_and_ref_index = new_cp_index;
3509 }
3510 log_debug(redefine, class, stackmap)
3511 ("frame_i=%u, frame_type=%u, name_and_ref_index=%d", frame_i, frame_type, name_and_ref_index);
3512
3513 stackmap_p_ref += 2;
3514 }
3515 } // rewrite_cp_refs_in_early_larval_stackmaps
3516
3517 // Change the constant pool associated with klass scratch_class to scratch_cp.
3518 // scratch_cp_length elements are copied from scratch_cp to a smaller constant pool
3519 // and the smaller constant pool is associated with scratch_class.
3520 void VM_RedefineClasses::set_new_constant_pool(
3521 ClassLoaderData* loader_data,
3522 InstanceKlass* scratch_class, constantPoolHandle scratch_cp,
3523 int scratch_cp_length, TRAPS) {
3524 assert(scratch_cp->length() >= scratch_cp_length, "sanity check");
3525
3526 // scratch_cp is a merged constant pool and has enough space for a
3527 // worst case merge situation. We want to associate the minimum
3528 // sized constant pool with the klass to save space.
3529 ConstantPool* cp = ConstantPool::allocate(loader_data, scratch_cp_length, CHECK);
3530 constantPoolHandle smaller_cp(THREAD, cp);
3531
3532 // preserve version() value in the smaller copy
3533 int version = scratch_cp->version();
3534 assert(version != 0, "sanity check");
3535 smaller_cp->set_version(version);
3536
3537 // attach klass to new constant pool
3538 // reference to the cp holder is needed for reallocating the BSM attribute
3539 smaller_cp->set_pool_holder(scratch_class);
3540
3541 smaller_cp->copy_fields(scratch_cp());
3542
3543 scratch_cp->copy_cp_to(1, scratch_cp_length - 1, smaller_cp, 1, THREAD);
3544 if (HAS_PENDING_EXCEPTION) {
3545 // Exception is handled in the caller
3546 loader_data->add_to_deallocate_list(smaller_cp());
3547 return;
3548 }
3549 scratch_cp = smaller_cp;
3550
3551 // attach new constant pool to klass
3552 scratch_class->set_constants(scratch_cp());
3553 scratch_cp->initialize_unresolved_klasses(loader_data, CHECK);
3554
3555 int i; // for portability
3556
3557 // update each field in klass to use new constant pool indices as needed
3558 int java_fields;
3559 int injected_fields;
3560 bool update_required = false;
3561 GrowableArray<FieldInfo>* fields = FieldInfoStream::create_FieldInfoArray(scratch_class->fieldinfo_stream(), &java_fields, &injected_fields);
3562 for (int i = 0; i < java_fields; i++) {
3563 FieldInfo* fi = fields->adr_at(i);
3564 jshort cur_index = fi->name_index();
3565 jshort new_index = find_new_index(cur_index);
3566 if (new_index != 0) {
3567 log_trace(redefine, class, constantpool)("field-name_index change: %d to %d", cur_index, new_index);
3568 fi->set_name_index(new_index);
3569 update_required = true;
3570 }
3571 cur_index = fi->signature_index();
3572 new_index = find_new_index(cur_index);
3573 if (new_index != 0) {
3574 log_trace(redefine, class, constantpool)("field-signature_index change: %d to %d", cur_index, new_index);
3575 fi->set_signature_index(new_index);
3576 update_required = true;
3577 }
3578 cur_index = fi->initializer_index();
3579 new_index = find_new_index(cur_index);
3580 if (new_index != 0) {
3581 log_trace(redefine, class, constantpool)("field-initval_index change: %d to %d", cur_index, new_index);
3582 fi->set_initializer_index(new_index);
3583 update_required = true;
3584 }
3585 cur_index = fi->generic_signature_index();
3586 new_index = find_new_index(cur_index);
3587 if (new_index != 0) {
3588 log_trace(redefine, class, constantpool)("field-generic_signature change: %d to %d", cur_index, new_index);
3589 fi->set_generic_signature_index(new_index);
3590 update_required = true;
3591 }
3592 }
3593 if (update_required) {
3594 Array<u1>* old_stream = scratch_class->fieldinfo_stream();
3595 assert(fields->length() == (java_fields + injected_fields), "Must be");
3596 Array<u1>* new_fis = FieldInfoStream::create_FieldInfoStream(fields, java_fields, injected_fields, scratch_class->class_loader_data(), CHECK);
3597 scratch_class->set_fieldinfo_stream(new_fis);
3598 MetadataFactory::free_array<u1>(scratch_class->class_loader_data(), old_stream);
3599
3600 Array<u1>* old_table = scratch_class->fieldinfo_search_table();
3601 Array<u1>* search_table = FieldInfoStream::create_search_table(scratch_class->constants(), new_fis, scratch_class->class_loader_data(), CHECK);
3602 scratch_class->set_fieldinfo_search_table(search_table);
3603 MetadataFactory::free_array<u1>(scratch_class->class_loader_data(), old_table);
3604
3605 DEBUG_ONLY(FieldInfoStream::validate_search_table(scratch_class->constants(), new_fis, search_table));
3606 }
3607
3608 // Update constant pool indices in the inner classes info to use
3609 // new constant indices as needed. The inner classes info is a
3610 // quadruple:
3611 // (inner_class_info, outer_class_info, inner_name, inner_access_flags)
3612 InnerClassesIterator iter(scratch_class);
3613 for (; !iter.done(); iter.next()) {
3614 int cur_index = iter.inner_class_info_index();
3615 if (cur_index == 0) {
3616 continue; // JVM spec. allows null inner class refs so skip it
3617 }
3618 u2 new_index = find_new_index(cur_index);
3619 if (new_index != 0) {
3620 log_trace(redefine, class, constantpool)("inner_class_info change: %d to %d", cur_index, new_index);
3621 iter.set_inner_class_info_index(new_index);
3622 }
3623 cur_index = iter.outer_class_info_index();
3624 new_index = find_new_index(cur_index);
3625 if (new_index != 0) {
3626 log_trace(redefine, class, constantpool)("outer_class_info change: %d to %d", cur_index, new_index);
3627 iter.set_outer_class_info_index(new_index);
3628 }
3629 cur_index = iter.inner_name_index();
3630 new_index = find_new_index(cur_index);
3631 if (new_index != 0) {
3632 log_trace(redefine, class, constantpool)("inner_name change: %d to %d", cur_index, new_index);
3633 iter.set_inner_name_index(new_index);
3634 }
3635 } // end for each inner class
3636
3637 // Attach each method in klass to the new constant pool and update
3638 // to use new constant pool indices as needed:
3639 Array<Method*>* methods = scratch_class->methods();
3640 for (i = methods->length() - 1; i >= 0; i--) {
3641 methodHandle method(THREAD, methods->at(i));
3642 method->set_constants(scratch_cp());
3643
3644 u2 new_index = find_new_index(method->name_index());
3645 if (new_index != 0) {
3646 log_trace(redefine, class, constantpool)
3647 ("method-name_index change: %d to %d", method->name_index(), new_index);
3648 method->set_name_index(new_index);
3649 }
3650 new_index = find_new_index(method->signature_index());
3651 if (new_index != 0) {
3652 log_trace(redefine, class, constantpool)
3653 ("method-signature_index change: %d to %d", method->signature_index(), new_index);
3654 method->set_signature_index(new_index);
3655 }
3656 new_index = find_new_index(method->generic_signature_index());
3657 if (new_index != 0) {
3658 log_trace(redefine, class, constantpool)
3659 ("method-generic_signature_index change: %d to %d", method->generic_signature_index(), new_index);
3660 method->constMethod()->set_generic_signature_index(new_index);
3661 }
3662
3663 // Update constant pool indices in the method's checked exception
3664 // table to use new constant indices as needed.
3665 int cext_length = method->checked_exceptions_length();
3666 if (cext_length > 0) {
3667 CheckedExceptionElement * cext_table =
3668 method->checked_exceptions_start();
3669 for (int j = 0; j < cext_length; j++) {
3670 int cur_index = cext_table[j].class_cp_index;
3671 int new_index = find_new_index(cur_index);
3672 if (new_index != 0) {
3673 log_trace(redefine, class, constantpool)("cext-class_cp_index change: %d to %d", cur_index, new_index);
3674 cext_table[j].class_cp_index = (u2)new_index;
3675 }
3676 } // end for each checked exception table entry
3677 } // end if there are checked exception table entries
3678
3679 // Update each catch type index in the method's exception table
3680 // to use new constant pool indices as needed. The exception table
3681 // holds quadruple entries of the form:
3682 // (beg_bci, end_bci, handler_bci, klass_index)
3683
3684 ExceptionTable ex_table(method());
3685 int ext_length = ex_table.length();
3686
3687 for (int j = 0; j < ext_length; j ++) {
3688 int cur_index = ex_table.catch_type_index(j);
3689 u2 new_index = find_new_index(cur_index);
3690 if (new_index != 0) {
3691 log_trace(redefine, class, constantpool)("ext-klass_index change: %d to %d", cur_index, new_index);
3692 ex_table.set_catch_type_index(j, new_index);
3693 }
3694 } // end for each exception table entry
3695
3696 // Update constant pool indices in the method's local variable
3697 // table to use new constant indices as needed. The local variable
3698 // table hold sextuple entries of the form:
3699 // (start_pc, length, name_index, descriptor_index, signature_index, slot)
3700 int lvt_length = method->localvariable_table_length();
3701 if (lvt_length > 0) {
3702 LocalVariableTableElement * lv_table =
3703 method->localvariable_table_start();
3704 for (int j = 0; j < lvt_length; j++) {
3705 int cur_index = lv_table[j].name_cp_index;
3706 int new_index = find_new_index(cur_index);
3707 if (new_index != 0) {
3708 log_trace(redefine, class, constantpool)("lvt-name_cp_index change: %d to %d", cur_index, new_index);
3709 lv_table[j].name_cp_index = (u2)new_index;
3710 }
3711 cur_index = lv_table[j].descriptor_cp_index;
3712 new_index = find_new_index(cur_index);
3713 if (new_index != 0) {
3714 log_trace(redefine, class, constantpool)("lvt-descriptor_cp_index change: %d to %d", cur_index, new_index);
3715 lv_table[j].descriptor_cp_index = (u2)new_index;
3716 }
3717 cur_index = lv_table[j].signature_cp_index;
3718 new_index = find_new_index(cur_index);
3719 if (new_index != 0) {
3720 log_trace(redefine, class, constantpool)("lvt-signature_cp_index change: %d to %d", cur_index, new_index);
3721 lv_table[j].signature_cp_index = (u2)new_index;
3722 }
3723 } // end for each local variable table entry
3724 } // end if there are local variable table entries
3725
3726 // Update constant pool indices in the method's method_parameters.
3727 int mp_length = method->method_parameters_length();
3728 if (mp_length > 0) {
3729 MethodParametersElement* elem = method->method_parameters_start();
3730 for (int j = 0; j < mp_length; j++) {
3731 const int cp_index = elem[j].name_cp_index;
3732 const int new_cp_index = find_new_index(cp_index);
3733 if (new_cp_index != 0) {
3734 elem[j].name_cp_index = (u2)new_cp_index;
3735 }
3736 }
3737 }
3738
3739 rewrite_cp_refs_in_stack_map_table(method);
3740 } // end for each method
3741 } // end set_new_constant_pool()
3742
3743
3744 // Unevolving classes may point to methods of the_class directly
3745 // from their constant pool caches, itables, and/or vtables. We
3746 // use the ClassLoaderDataGraph::classes_do() facility and this helper
3747 // to fix up these pointers. MethodData also points to old methods and
3748 // must be cleaned.
3749
3750 // Adjust cpools and vtables closure
3751 void VM_RedefineClasses::AdjustAndCleanMetadata::do_klass(Klass* k) {
3752
3753 // This is a very busy routine. We don't want too much tracing
3754 // printed out.
3755 bool trace_name_printed = false;
3756
3757 // If the class being redefined is java.lang.Object, we need to fix all
3758 // array class vtables also. The _has_redefined_Object flag is global.
3759 // Once the java.lang.Object has been redefined (by the current or one
3760 // of the previous VM_RedefineClasses operations) we have to always
3761 // adjust method entries for array classes.
3762 if (k->is_array_klass() && _has_redefined_Object) {
3763 k->vtable().adjust_method_entries(&trace_name_printed);
3764
3765 } else if (k->is_instance_klass()) {
3766 HandleMark hm(_thread);
3767 InstanceKlass *ik = InstanceKlass::cast(k);
3768
3769 // Clean MethodData of this class's methods so they don't refer to
3770 // old methods that are no longer running.
3771 Array<Method*>* methods = ik->methods();
3772 int num_methods = methods->length();
3773 for (int index = 0; index < num_methods; ++index) {
3774 if (methods->at(index)->method_data() != nullptr) {
3775 methods->at(index)->method_data()->clean_weak_method_links();
3776 }
3777 }
3778
3779 // Adjust all vtables, default methods and itables, to clean out old methods.
3780 ResourceMark rm(_thread);
3781 if (ik->vtable_length() > 0) {
3782 ik->vtable().adjust_method_entries(&trace_name_printed);
3783 ik->adjust_default_methods(&trace_name_printed);
3784 }
3785
3786 if (ik->itable_length() > 0) {
3787 ik->itable().adjust_method_entries(&trace_name_printed);
3788 }
3789
3790 // The constant pools in other classes (other_cp) can refer to
3791 // old methods. We have to update method information in
3792 // other_cp's cache. If other_cp has a previous version, then we
3793 // have to repeat the process for each previous version. The
3794 // constant pool cache holds the Method*s for non-virtual
3795 // methods and for virtual, final methods.
3796 //
3797 // Special case: if the current class is being redefined by the current
3798 // VM_RedefineClasses operation, then new_cp has already been attached
3799 // to the_class and old_cp has already been added as a previous version.
3800 // The new_cp doesn't have any cached references to old methods so it
3801 // doesn't need to be updated and we could optimize by skipping it.
3802 // However, the current class can be marked as being redefined by another
3803 // VM_RedefineClasses operation which has already executed its doit_prologue
3804 // and needs cpcache method entries adjusted. For simplicity, the cpcache
3805 // update is done unconditionally. It should result in doing nothing for
3806 // classes being redefined by the current VM_RedefineClasses operation.
3807 // Method entries in the previous version(s) are adjusted as well.
3808 ConstantPoolCache* cp_cache;
3809
3810 // this klass' constant pool cache may need adjustment
3811 ConstantPool* other_cp = ik->constants();
3812 cp_cache = other_cp->cache();
3813 if (cp_cache != nullptr) {
3814 cp_cache->adjust_method_entries(&trace_name_printed);
3815 }
3816
3817 // the previous versions' constant pool caches may need adjustment
3818 for (InstanceKlass* pv_node = ik->previous_versions();
3819 pv_node != nullptr;
3820 pv_node = pv_node->previous_versions()) {
3821 cp_cache = pv_node->constants()->cache();
3822 if (cp_cache != nullptr) {
3823 cp_cache->adjust_method_entries(&trace_name_printed);
3824 }
3825 }
3826 }
3827 }
3828
3829 void VM_RedefineClasses::update_jmethod_ids() {
3830 for (int j = 0; j < _matching_methods_length; ++j) {
3831 Method* old_method = _matching_old_methods[j];
3832 // The method_idnum should be within the range of 1..number-of-methods
3833 // until incremented later for obsolete methods.
3834 // The increment is so if a jmethodID is created for an old obsolete method
3835 // it gets a new jmethodID cache slot in the InstanceKlass.
3836 // They're cleaned out later when all methods of the previous version are purged.
3837 assert(old_method->method_idnum() <= _old_methods->length(),
3838 "shouldn't be incremented yet for obsolete methods");
3839 jmethodID jmid = old_method->find_jmethod_id_or_null();
3840 if (jmid != nullptr) {
3841 // There is a jmethodID, change it to point to the new method
3842 Method* new_method = _matching_new_methods[j];
3843 Method::change_method_associated_with_jmethod_id(jmid, new_method);
3844 assert(Method::resolve_jmethod_id(jmid) == _matching_new_methods[j],
3845 "should be replaced");
3846 }
3847 }
3848 }
3849
3850 int VM_RedefineClasses::check_methods_and_mark_as_obsolete() {
3851 int emcp_method_count = 0;
3852 int obsolete_count = 0;
3853 int old_index = 0;
3854 for (int j = 0; j < _matching_methods_length; ++j, ++old_index) {
3855 Method* old_method = _matching_old_methods[j];
3856 Method* new_method = _matching_new_methods[j];
3857 Method* old_array_method;
3858
3859 // Maintain an old_index into the _old_methods array by skipping
3860 // deleted methods
3861 while ((old_array_method = _old_methods->at(old_index)) != old_method) {
3862 ++old_index;
3863 }
3864
3865 if (MethodComparator::methods_EMCP(old_method, new_method)) {
3866 // The EMCP definition from JSR-163 requires the bytecodes to be
3867 // the same with the exception of constant pool indices which may
3868 // differ. However, the constants referred to by those indices
3869 // must be the same.
3870 //
3871 // We use methods_EMCP() for comparison since constant pool
3872 // merging can remove duplicate constant pool entries that were
3873 // present in the old method and removed from the rewritten new
3874 // method. A faster binary comparison function would consider the
3875 // old and new methods to be different when they are actually
3876 // EMCP.
3877 //
3878 // The old and new methods are EMCP and you would think that we
3879 // could get rid of one of them here and now and save some space.
3880 // However, the concept of EMCP only considers the bytecodes and
3881 // the constant pool entries in the comparison. Other things,
3882 // e.g., the line number table (LNT) or the local variable table
3883 // (LVT) don't count in the comparison. So the new (and EMCP)
3884 // method can have a new LNT that we need so we can't just
3885 // overwrite the new method with the old method.
3886 //
3887 // When this routine is called, we have already attached the new
3888 // methods to the_class so the old methods are effectively
3889 // overwritten. However, if an old method is still executing,
3890 // then the old method cannot be collected until sometime after
3891 // the old method call has returned. So the overwriting of old
3892 // methods by new methods will save us space except for those
3893 // (hopefully few) old methods that are still executing.
3894 //
3895 // A method refers to a ConstMethod* and this presents another
3896 // possible avenue to space savings. The ConstMethod* in the
3897 // new method contains possibly new attributes (LNT, LVT, etc).
3898 // At first glance, it seems possible to save space by replacing
3899 // the ConstMethod* in the old method with the ConstMethod*
3900 // from the new method. The old and new methods would share the
3901 // same ConstMethod* and we would save the space occupied by
3902 // the old ConstMethod*. However, the ConstMethod* contains
3903 // a back reference to the containing method. Sharing the
3904 // ConstMethod* between two methods could lead to confusion in
3905 // the code that uses the back reference. This would lead to
3906 // brittle code that could be broken in non-obvious ways now or
3907 // in the future.
3908 //
3909 // Another possibility is to copy the ConstMethod* from the new
3910 // method to the old method and then overwrite the new method with
3911 // the old method. Since the ConstMethod* contains the bytecodes
3912 // for the method embedded in the oop, this option would change
3913 // the bytecodes out from under any threads executing the old
3914 // method and make the thread's bcp invalid. Since EMCP requires
3915 // that the bytecodes be the same modulo constant pool indices, it
3916 // is straight forward to compute the correct new bcp in the new
3917 // ConstMethod* from the old bcp in the old ConstMethod*. The
3918 // time consuming part would be searching all the frames in all
3919 // of the threads to find all of the calls to the old method.
3920 //
3921 // It looks like we will have to live with the limited savings
3922 // that we get from effectively overwriting the old methods
3923 // when the new methods are attached to the_class.
3924
3925 // Count number of methods that are EMCP. The method will be marked
3926 // old but not obsolete if it is EMCP.
3927 emcp_method_count++;
3928
3929 // An EMCP method is _not_ obsolete. An obsolete method has a
3930 // different jmethodID than the current method. An EMCP method
3931 // has the same jmethodID as the current method. Having the
3932 // same jmethodID for all EMCP versions of a method allows for
3933 // a consistent view of the EMCP methods regardless of which
3934 // EMCP method you happen to have in hand. For example, a
3935 // breakpoint set in one EMCP method will work for all EMCP
3936 // versions of the method including the current one.
3937 } else {
3938 // mark obsolete methods as such
3939 old_method->set_is_obsolete();
3940 obsolete_count++;
3941
3942 // obsolete methods need a unique idnum so they become new entries in
3943 // the jmethodID cache in InstanceKlass
3944 assert(old_method->method_idnum() == new_method->method_idnum(), "must match");
3945 u2 num = InstanceKlass::cast(_the_class)->next_method_idnum();
3946 if (num != ConstMethod::UNSET_IDNUM) {
3947 old_method->set_method_idnum(num);
3948 }
3949
3950 // With tracing we try not to "yack" too much. The position of
3951 // this trace assumes there are fewer obsolete methods than
3952 // EMCP methods.
3953 if (log_is_enabled(Trace, redefine, class, obsolete, mark)) {
3954 ResourceMark rm;
3955 log_trace(redefine, class, obsolete, mark)
3956 ("mark %s(%s) as obsolete", old_method->name()->as_C_string(), old_method->signature()->as_C_string());
3957 }
3958 }
3959 old_method->set_is_old();
3960 }
3961 for (int i = 0; i < _deleted_methods_length; ++i) {
3962 Method* old_method = _deleted_methods[i];
3963
3964 assert(!old_method->has_vtable_index(),
3965 "cannot delete methods with vtable entries");;
3966
3967 // Mark all deleted methods as old, obsolete and deleted
3968 old_method->set_is_deleted();
3969 old_method->set_is_old();
3970 old_method->set_is_obsolete();
3971 ++obsolete_count;
3972 // With tracing we try not to "yack" too much. The position of
3973 // this trace assumes there are fewer obsolete methods than
3974 // EMCP methods.
3975 if (log_is_enabled(Trace, redefine, class, obsolete, mark)) {
3976 ResourceMark rm;
3977 log_trace(redefine, class, obsolete, mark)
3978 ("mark deleted %s(%s) as obsolete", old_method->name()->as_C_string(), old_method->signature()->as_C_string());
3979 }
3980 }
3981 assert((emcp_method_count + obsolete_count) == _old_methods->length(),
3982 "sanity check");
3983 log_trace(redefine, class, obsolete, mark)("EMCP_cnt=%d, obsolete_cnt=%d", emcp_method_count, obsolete_count);
3984 return emcp_method_count;
3985 }
3986
3987 // This internal class transfers the native function registration from old methods
3988 // to new methods. It is designed to handle both the simple case of unchanged
3989 // native methods and the complex cases of native method prefixes being added and/or
3990 // removed.
3991 // It expects only to be used during the VM_RedefineClasses op (a safepoint).
3992 //
3993 // This class is used after the new methods have been installed in "the_class".
3994 //
3995 // So, for example, the following must be handled. Where 'm' is a method and
3996 // a number followed by an underscore is a prefix.
3997 //
3998 // Old Name New Name
3999 // Simple transfer to new method m -> m
4000 // Add prefix m -> 1_m
4001 // Remove prefix 1_m -> m
4002 // Simultaneous add of prefixes m -> 3_2_1_m
4003 // Simultaneous removal of prefixes 3_2_1_m -> m
4004 // Simultaneous add and remove 1_m -> 2_m
4005 // Same, caused by prefix removal only 3_2_1_m -> 3_2_m
4006 //
4007 class TransferNativeFunctionRegistration {
4008 private:
4009 InstanceKlass* the_class;
4010 int prefix_count;
4011 char** prefixes;
4012
4013 // Recursively search the binary tree of possibly prefixed method names.
4014 // Iteration could be used if all agents were well behaved. Full tree walk is
4015 // more resilent to agents not cleaning up intermediate methods.
4016 // Branch at each depth in the binary tree is:
4017 // (1) without the prefix.
4018 // (2) with the prefix.
4019 // where 'prefix' is the prefix at that 'depth' (first prefix, second prefix,...)
4020 Method* search_prefix_name_space(int depth, char* name_str, size_t name_len,
4021 Symbol* signature) {
4022 TempNewSymbol name_symbol = SymbolTable::probe(name_str, (int)name_len);
4023 if (name_symbol != nullptr) {
4024 Method* method = the_class->lookup_method(name_symbol, signature);
4025 if (method != nullptr) {
4026 // Even if prefixed, intermediate methods must exist.
4027 if (method->is_native()) {
4028 // Wahoo, we found a (possibly prefixed) version of the method, return it.
4029 return method;
4030 }
4031 if (depth < prefix_count) {
4032 // Try applying further prefixes (other than this one).
4033 method = search_prefix_name_space(depth+1, name_str, name_len, signature);
4034 if (method != nullptr) {
4035 return method; // found
4036 }
4037
4038 // Try adding this prefix to the method name and see if it matches
4039 // another method name.
4040 char* prefix = prefixes[depth];
4041 size_t prefix_len = strlen(prefix);
4042 size_t trial_len = name_len + prefix_len;
4043 char* trial_name_str = NEW_RESOURCE_ARRAY(char, trial_len + 1);
4044 strcpy(trial_name_str, prefix);
4045 strcat(trial_name_str, name_str);
4046 method = search_prefix_name_space(depth+1, trial_name_str, trial_len,
4047 signature);
4048 if (method != nullptr) {
4049 // If found along this branch, it was prefixed, mark as such
4050 method->set_is_prefixed_native();
4051 return method; // found
4052 }
4053 }
4054 }
4055 }
4056 return nullptr; // This whole branch bore nothing
4057 }
4058
4059 // Return the method name with old prefixes stripped away.
4060 char* method_name_without_prefixes(Method* method) {
4061 Symbol* name = method->name();
4062 char* name_str = name->as_utf8();
4063
4064 // Old prefixing may be defunct, strip prefixes, if any.
4065 for (int i = prefix_count-1; i >= 0; i--) {
4066 char* prefix = prefixes[i];
4067 size_t prefix_len = strlen(prefix);
4068 if (strncmp(prefix, name_str, prefix_len) == 0) {
4069 name_str += prefix_len;
4070 }
4071 }
4072 return name_str;
4073 }
4074
4075 // Strip any prefixes off the old native method, then try to find a
4076 // (possibly prefixed) new native that matches it.
4077 Method* strip_and_search_for_new_native(Method* method) {
4078 ResourceMark rm;
4079 char* name_str = method_name_without_prefixes(method);
4080 return search_prefix_name_space(0, name_str, strlen(name_str),
4081 method->signature());
4082 }
4083
4084 public:
4085
4086 // Construct a native method transfer processor for this class.
4087 TransferNativeFunctionRegistration(InstanceKlass* _the_class) {
4088 assert(SafepointSynchronize::is_at_safepoint(), "sanity check");
4089
4090 the_class = _the_class;
4091 prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count);
4092 }
4093
4094 // Attempt to transfer any of the old or deleted methods that are native
4095 void transfer_registrations(Method** old_methods, int methods_length) {
4096 for (int j = 0; j < methods_length; j++) {
4097 Method* old_method = old_methods[j];
4098
4099 if (old_method->is_native() && old_method->has_native_function()) {
4100 Method* new_method = strip_and_search_for_new_native(old_method);
4101 if (new_method != nullptr) {
4102 // Actually set the native function in the new method.
4103 // Redefine does not send events (except CFLH), certainly not this
4104 // behind the scenes re-registration.
4105 new_method->set_native_function(old_method->native_function(),
4106 !Method::native_bind_event_is_interesting);
4107 }
4108 }
4109 }
4110 }
4111 };
4112
4113 // Don't lose the association between a native method and its JNI function.
4114 void VM_RedefineClasses::transfer_old_native_function_registrations(InstanceKlass* the_class) {
4115 TransferNativeFunctionRegistration transfer(the_class);
4116 transfer.transfer_registrations(_deleted_methods, _deleted_methods_length);
4117 transfer.transfer_registrations(_matching_old_methods, _matching_methods_length);
4118 }
4119
4120 // Deoptimize all compiled code that depends on the classes redefined.
4121 //
4122 // If the can_redefine_classes capability is obtained in the onload
4123 // phase or 'AlwaysRecordEvolDependencies' is true, then the compiler has
4124 // recorded all dependencies from startup. In that case we need only
4125 // deoptimize and throw away all compiled code that depends on the class.
4126 //
4127 // If can_redefine_classes is obtained sometime after the onload phase
4128 // (and 'AlwaysRecordEvolDependencies' is false) then the dependency
4129 // information may be incomplete. In that case the first call to
4130 // RedefineClasses causes all compiled code to be thrown away. As
4131 // can_redefine_classes has been obtained then all future compilations will
4132 // record dependencies so second and subsequent calls to RedefineClasses
4133 // need only throw away code that depends on the class.
4134 //
4135
4136 void VM_RedefineClasses::flush_dependent_code() {
4137 assert(SafepointSynchronize::is_at_safepoint(), "sanity check");
4138 assert(JvmtiExport::all_dependencies_are_recorded() || !AlwaysRecordEvolDependencies, "sanity check");
4139
4140 DeoptimizationScope deopt_scope;
4141
4142 // This is the first redefinition, mark all the nmethods for deoptimization
4143 if (!JvmtiExport::all_dependencies_are_recorded()) {
4144 CodeCache::mark_all_nmethods_for_evol_deoptimization(&deopt_scope);
4145 log_debug(redefine, class, nmethod)("Marked all nmethods for deopt");
4146 } else {
4147 CodeCache::mark_dependents_for_evol_deoptimization(&deopt_scope);
4148 log_debug(redefine, class, nmethod)("Marked dependent nmethods for deopt");
4149 }
4150
4151 deopt_scope.deoptimize_marked();
4152
4153 // From now on we know that the dependency information is complete
4154 JvmtiExport::set_all_dependencies_are_recorded(true);
4155 }
4156
4157 void VM_RedefineClasses::compute_added_deleted_matching_methods() {
4158 Method* old_method;
4159 Method* new_method;
4160
4161 _matching_old_methods = NEW_RESOURCE_ARRAY(Method*, _old_methods->length());
4162 _matching_new_methods = NEW_RESOURCE_ARRAY(Method*, _old_methods->length());
4163 _added_methods = NEW_RESOURCE_ARRAY(Method*, _new_methods->length());
4164 _deleted_methods = NEW_RESOURCE_ARRAY(Method*, _old_methods->length());
4165
4166 _matching_methods_length = 0;
4167 _deleted_methods_length = 0;
4168 _added_methods_length = 0;
4169
4170 int nj = 0;
4171 int oj = 0;
4172 while (true) {
4173 if (oj >= _old_methods->length()) {
4174 if (nj >= _new_methods->length()) {
4175 break; // we've looked at everything, done
4176 }
4177 // New method at the end
4178 new_method = _new_methods->at(nj);
4179 _added_methods[_added_methods_length++] = new_method;
4180 ++nj;
4181 } else if (nj >= _new_methods->length()) {
4182 // Old method, at the end, is deleted
4183 old_method = _old_methods->at(oj);
4184 _deleted_methods[_deleted_methods_length++] = old_method;
4185 ++oj;
4186 } else {
4187 old_method = _old_methods->at(oj);
4188 new_method = _new_methods->at(nj);
4189 if (old_method->name() == new_method->name()) {
4190 if (old_method->signature() == new_method->signature()) {
4191 _matching_old_methods[_matching_methods_length ] = old_method;
4192 _matching_new_methods[_matching_methods_length++] = new_method;
4193 ++nj;
4194 ++oj;
4195 } else {
4196 // added overloaded have already been moved to the end,
4197 // so this is a deleted overloaded method
4198 _deleted_methods[_deleted_methods_length++] = old_method;
4199 ++oj;
4200 }
4201 } else { // names don't match
4202 if (old_method->name()->fast_compare(new_method->name()) > 0) {
4203 // new method
4204 _added_methods[_added_methods_length++] = new_method;
4205 ++nj;
4206 } else {
4207 // deleted method
4208 _deleted_methods[_deleted_methods_length++] = old_method;
4209 ++oj;
4210 }
4211 }
4212 }
4213 }
4214 assert(_matching_methods_length + _deleted_methods_length == _old_methods->length(), "sanity");
4215 assert(_matching_methods_length + _added_methods_length == _new_methods->length(), "sanity");
4216 }
4217
4218
4219 void VM_RedefineClasses::swap_annotations(InstanceKlass* the_class,
4220 InstanceKlass* scratch_class) {
4221 // Swap annotation fields values
4222 Annotations* old_annotations = the_class->annotations();
4223 the_class->set_annotations(scratch_class->annotations());
4224 scratch_class->set_annotations(old_annotations);
4225 }
4226
4227
4228 // Install the redefinition of a class:
4229 // - house keeping (flushing breakpoints and caches, deoptimizing
4230 // dependent compiled code)
4231 // - replacing parts in the_class with parts from scratch_class
4232 // - adding a weak reference to track the obsolete but interesting
4233 // parts of the_class
4234 // - adjusting constant pool caches and vtables in other classes
4235 // that refer to methods in the_class. These adjustments use the
4236 // ClassLoaderDataGraph::classes_do() facility which only allows
4237 // a helper method to be specified. The interesting parameters
4238 // that we would like to pass to the helper method are saved in
4239 // static global fields in the VM operation.
4240 void VM_RedefineClasses::redefine_single_class(Thread* current, jclass the_jclass,
4241 InstanceKlass* scratch_class) {
4242
4243 HandleMark hm(current); // make sure handles from this call are freed
4244
4245 if (log_is_enabled(Info, redefine, class, timer)) {
4246 _timer_rsc_phase1.start();
4247 }
4248
4249 InstanceKlass* the_class = get_ik(the_jclass);
4250
4251 // Set a flag to control and optimize adjusting method entries
4252 _has_redefined_Object |= the_class == vmClasses::Object_klass();
4253
4254 // Remove all breakpoints in methods of this class
4255 JvmtiBreakpoints& jvmti_breakpoints = JvmtiCurrentBreakpoints::get_jvmti_breakpoints();
4256 jvmti_breakpoints.clearall_in_class_at_safepoint(the_class);
4257
4258 _old_methods = the_class->methods();
4259 _new_methods = scratch_class->methods();
4260 _the_class = the_class;
4261 compute_added_deleted_matching_methods();
4262 update_jmethod_ids();
4263
4264 _any_class_has_resolved_methods = the_class->has_resolved_methods() || _any_class_has_resolved_methods;
4265
4266 // Attach new constant pool to the original klass. The original
4267 // klass still refers to the old constant pool (for now).
4268 scratch_class->constants()->set_pool_holder(the_class);
4269
4270 #if 0
4271 // In theory, with constant pool merging in place we should be able
4272 // to save space by using the new, merged constant pool in place of
4273 // the old constant pool(s). By "pool(s)" I mean the constant pool in
4274 // the klass version we are replacing now and any constant pool(s) in
4275 // previous versions of klass. Nice theory, doesn't work in practice.
4276 // When this code is enabled, even simple programs throw NullPointer
4277 // exceptions. I'm guessing that this is caused by some constant pool
4278 // cache difference between the new, merged constant pool and the
4279 // constant pool that was just being used by the klass. I'm keeping
4280 // this code around to archive the idea, but the code has to remain
4281 // disabled for now.
4282
4283 // Attach each old method to the new constant pool. This can be
4284 // done here since we are past the bytecode verification and
4285 // constant pool optimization phases.
4286 for (int i = _old_methods->length() - 1; i >= 0; i--) {
4287 Method* method = _old_methods->at(i);
4288 method->set_constants(scratch_class->constants());
4289 }
4290
4291 // NOTE: this doesn't work because you can redefine the same class in two
4292 // threads, each getting their own constant pool data appended to the
4293 // original constant pool. In order for the new methods to work when they
4294 // become old methods, they need to keep their updated copy of the constant pool.
4295
4296 {
4297 // walk all previous versions of the klass
4298 InstanceKlass *ik = the_class;
4299 PreviousVersionWalker pvw(ik);
4300 do {
4301 ik = pvw.next_previous_version();
4302 if (ik != nullptr) {
4303
4304 // attach previous version of klass to the new constant pool
4305 ik->set_constants(scratch_class->constants());
4306
4307 // Attach each method in the previous version of klass to the
4308 // new constant pool
4309 Array<Method*>* prev_methods = ik->methods();
4310 for (int i = prev_methods->length() - 1; i >= 0; i--) {
4311 Method* method = prev_methods->at(i);
4312 method->set_constants(scratch_class->constants());
4313 }
4314 }
4315 } while (ik != nullptr);
4316 }
4317 #endif
4318
4319 // Replace methods and constantpool
4320 the_class->set_methods(_new_methods);
4321 scratch_class->set_methods(_old_methods); // To prevent potential GCing of the old methods,
4322 // and to be able to undo operation easily.
4323
4324 Array<int>* old_ordering = the_class->method_ordering();
4325 the_class->set_method_ordering(scratch_class->method_ordering());
4326 scratch_class->set_method_ordering(old_ordering);
4327
4328 ConstantPool* old_constants = the_class->constants();
4329 the_class->set_constants(scratch_class->constants());
4330 scratch_class->set_constants(old_constants); // See the previous comment.
4331 #if 0
4332 // We are swapping the guts of "the new class" with the guts of "the
4333 // class". Since the old constant pool has just been attached to "the
4334 // new class", it seems logical to set the pool holder in the old
4335 // constant pool also. However, doing this will change the observable
4336 // class hierarchy for any old methods that are still executing. A
4337 // method can query the identity of its "holder" and this query uses
4338 // the method's constant pool link to find the holder. The change in
4339 // holding class from "the class" to "the new class" can confuse
4340 // things.
4341 //
4342 // Setting the old constant pool's holder will also cause
4343 // verification done during vtable initialization below to fail.
4344 // During vtable initialization, the vtable's class is verified to be
4345 // a subtype of the method's holder. The vtable's class is "the
4346 // class" and the method's holder is gotten from the constant pool
4347 // link in the method itself. For "the class"'s directly implemented
4348 // methods, the method holder is "the class" itself (as gotten from
4349 // the new constant pool). The check works fine in this case. The
4350 // check also works fine for methods inherited from super classes.
4351 //
4352 // Miranda methods are a little more complicated. A miranda method is
4353 // provided by an interface when the class implementing the interface
4354 // does not provide its own method. These interfaces are implemented
4355 // internally as an InstanceKlass. These special instanceKlasses
4356 // share the constant pool of the class that "implements" the
4357 // interface. By sharing the constant pool, the method holder of a
4358 // miranda method is the class that "implements" the interface. In a
4359 // non-redefine situation, the subtype check works fine. However, if
4360 // the old constant pool's pool holder is modified, then the check
4361 // fails because there is no class hierarchy relationship between the
4362 // vtable's class and "the new class".
4363
4364 old_constants->set_pool_holder(scratch_class());
4365 #endif
4366
4367 // track number of methods that are EMCP for add_previous_version() call below
4368 int emcp_method_count = check_methods_and_mark_as_obsolete();
4369 transfer_old_native_function_registrations(the_class);
4370
4371 if (scratch_class->get_cached_class_file() != the_class->get_cached_class_file()) {
4372 // 1. the_class doesn't have a cache yet, scratch_class does have a cache.
4373 // 2. The same class can be present twice in the scratch classes list or there
4374 // are multiple concurrent RetransformClasses calls on different threads.
4375 // the_class and scratch_class have the same cached bytes, but different buffers.
4376 // In such cases we need to deallocate one of the buffers.
4377 // 3. RedefineClasses and the_class has cached bytes from a previous transformation.
4378 // In the case we need to use class bytes from scratch_class.
4379 if (the_class->get_cached_class_file() != nullptr) {
4380 os::free(the_class->get_cached_class_file());
4381 }
4382 the_class->set_cached_class_file(scratch_class->get_cached_class_file());
4383 }
4384
4385 // null out in scratch class to not delete twice. The class to be redefined
4386 // always owns these bytes.
4387 scratch_class->set_cached_class_file(nullptr);
4388
4389 // Replace inner_classes
4390 Array<u2>* old_inner_classes = the_class->inner_classes();
4391 the_class->set_inner_classes(scratch_class->inner_classes());
4392 scratch_class->set_inner_classes(old_inner_classes);
4393
4394 // Initialize the vtable and interface table after
4395 // methods have been rewritten
4396 // no exception should happen here since we explicitly
4397 // do not check loader constraints.
4398 // compare_and_normalize_class_versions has already checked:
4399 // - classloaders unchanged, signatures unchanged
4400 // - all instanceKlasses for redefined classes reused & contents updated
4401 the_class->vtable().initialize_vtable();
4402 the_class->itable().initialize_itable();
4403
4404 // Update jmethodID cache if present.
4405 the_class->update_methods_jmethod_cache();
4406
4407 // Copy the "source debug extension" attribute from new class version
4408 the_class->set_source_debug_extension(
4409 scratch_class->source_debug_extension(),
4410 scratch_class->source_debug_extension() == nullptr ? 0 :
4411 (int)strlen(scratch_class->source_debug_extension()));
4412
4413 // Use of javac -g could be different in the old and the new
4414 if (scratch_class->has_localvariable_table() !=
4415 the_class->has_localvariable_table()) {
4416 the_class->set_has_localvariable_table(scratch_class->has_localvariable_table());
4417 }
4418
4419 swap_annotations(the_class, scratch_class);
4420
4421 // Replace minor version number of class file
4422 u2 old_minor_version = the_class->constants()->minor_version();
4423 the_class->constants()->set_minor_version(scratch_class->constants()->minor_version());
4424 scratch_class->constants()->set_minor_version(old_minor_version);
4425
4426 // Replace major version number of class file
4427 u2 old_major_version = the_class->constants()->major_version();
4428 the_class->constants()->set_major_version(scratch_class->constants()->major_version());
4429 scratch_class->constants()->set_major_version(old_major_version);
4430
4431 // Replace CP indexes for class and name+type of enclosing method
4432 u2 old_class_idx = the_class->enclosing_method_class_index();
4433 u2 old_method_idx = the_class->enclosing_method_method_index();
4434 the_class->set_enclosing_method_indices(
4435 scratch_class->enclosing_method_class_index(),
4436 scratch_class->enclosing_method_method_index());
4437 scratch_class->set_enclosing_method_indices(old_class_idx, old_method_idx);
4438
4439 if (!the_class->has_been_redefined()) {
4440 the_class->set_has_been_redefined();
4441 }
4442
4443 // Scratch class is unloaded but still needs cleaning, and skipping for CDS.
4444 scratch_class->set_is_scratch_class();
4445
4446 // keep track of previous versions of this class
4447 the_class->add_previous_version(scratch_class, emcp_method_count);
4448
4449 JFR_ONLY(Jfr::on_klass_redefinition(the_class, scratch_class);)
4450
4451 _timer_rsc_phase1.stop();
4452 if (log_is_enabled(Info, redefine, class, timer)) {
4453 _timer_rsc_phase2.start();
4454 }
4455
4456 if (the_class->oop_map_cache() != nullptr) {
4457 // Flush references to any obsolete methods from the oop map cache
4458 // so that obsolete methods are not pinned.
4459 the_class->oop_map_cache()->flush_obsolete_entries();
4460 }
4461
4462 increment_class_counter(the_class);
4463
4464 if (EventClassRedefinition::is_enabled()) {
4465 EventClassRedefinition event;
4466 event.set_classModificationCount(java_lang_Class::classRedefinedCount(the_class->java_mirror()));
4467 event.set_redefinedClass(the_class);
4468 event.set_redefinitionId(_id);
4469 event.commit();
4470 }
4471
4472 {
4473 ResourceMark rm(current);
4474 // increment the classRedefinedCount field in the_class and in any
4475 // direct and indirect subclasses of the_class
4476 physical_memory_size_type avail_mem = 0;
4477 // Return value ignored - defaulting to 0 on failure.
4478 (void)os::available_memory(avail_mem);
4479 log_info(redefine, class, load)
4480 ("redefined name=%s, count=%d (avail_mem=" PHYS_MEM_TYPE_FORMAT "K)",
4481 the_class->external_name(), java_lang_Class::classRedefinedCount(the_class->java_mirror()), avail_mem >> 10);
4482 Events::log_redefinition(current, "redefined class name=%s, count=%d",
4483 the_class->external_name(),
4484 java_lang_Class::classRedefinedCount(the_class->java_mirror()));
4485
4486 }
4487 _timer_rsc_phase2.stop();
4488
4489 } // end redefine_single_class()
4490
4491
4492 // Increment the classRedefinedCount field in the specific InstanceKlass
4493 // and in all direct and indirect subclasses.
4494 void VM_RedefineClasses::increment_class_counter(InstanceKlass* ik) {
4495 for (ClassHierarchyIterator iter(ik); !iter.done(); iter.next()) {
4496 // Only update instanceKlasses
4497 Klass* sub = iter.klass();
4498 if (sub->is_instance_klass()) {
4499 oop class_mirror = InstanceKlass::cast(sub)->java_mirror();
4500 Klass* class_oop = java_lang_Class::as_Klass(class_mirror);
4501 int new_count = java_lang_Class::classRedefinedCount(class_mirror) + 1;
4502 java_lang_Class::set_classRedefinedCount(class_mirror, new_count);
4503
4504 if (class_oop != _the_class) {
4505 // _the_class count is printed at end of redefine_single_class()
4506 log_debug(redefine, class, subclass)("updated count in subclass=%s to %d", ik->external_name(), new_count);
4507 }
4508 }
4509 }
4510 }
4511
4512 void VM_RedefineClasses::CheckClass::do_klass(Klass* k) {
4513 bool no_old_methods = true; // be optimistic
4514
4515 // Both array and instance classes have vtables.
4516 // a vtable should never contain old or obsolete methods
4517 ResourceMark rm(_thread);
4518 if (k->vtable_length() > 0 &&
4519 !k->vtable().check_no_old_or_obsolete_entries()) {
4520 if (log_is_enabled(Trace, redefine, class, obsolete, metadata)) {
4521 log_trace(redefine, class, obsolete, metadata)
4522 ("klassVtable::check_no_old_or_obsolete_entries failure -- OLD or OBSOLETE method found -- class: %s",
4523 k->signature_name());
4524 k->vtable().dump_vtable();
4525 }
4526 no_old_methods = false;
4527 }
4528
4529 if (k->is_instance_klass()) {
4530 HandleMark hm(_thread);
4531 InstanceKlass *ik = InstanceKlass::cast(k);
4532
4533 // an itable should never contain old or obsolete methods
4534 if (ik->itable_length() > 0 &&
4535 !ik->itable().check_no_old_or_obsolete_entries()) {
4536 if (log_is_enabled(Trace, redefine, class, obsolete, metadata)) {
4537 log_trace(redefine, class, obsolete, metadata)
4538 ("klassItable::check_no_old_or_obsolete_entries failure -- OLD or OBSOLETE method found -- class: %s",
4539 ik->signature_name());
4540 ik->itable().dump_itable();
4541 }
4542 no_old_methods = false;
4543 }
4544
4545 // the constant pool cache should never contain non-deleted old or obsolete methods
4546 if (ik->constants() != nullptr &&
4547 ik->constants()->cache() != nullptr &&
4548 !ik->constants()->cache()->check_no_old_or_obsolete_entries()) {
4549 if (log_is_enabled(Trace, redefine, class, obsolete, metadata)) {
4550 log_trace(redefine, class, obsolete, metadata)
4551 ("cp-cache::check_no_old_or_obsolete_entries failure -- OLD or OBSOLETE method found -- class: %s",
4552 ik->signature_name());
4553 ik->constants()->cache()->dump_cache();
4554 }
4555 no_old_methods = false;
4556 }
4557 }
4558
4559 // print and fail guarantee if old methods are found.
4560 if (!no_old_methods) {
4561 if (log_is_enabled(Trace, redefine, class, obsolete, metadata)) {
4562 dump_methods();
4563 } else {
4564 log_trace(redefine, class)("Use the '-Xlog:redefine+class*:' option "
4565 "to see more info about the following guarantee() failure.");
4566 }
4567 guarantee(false, "OLD and/or OBSOLETE method(s) found");
4568 }
4569 }
4570
4571 u8 VM_RedefineClasses::next_id() {
4572 while (true) {
4573 u8 id = _id_counter;
4574 u8 next_id = id + 1;
4575 u8 result = AtomicAccess::cmpxchg(&_id_counter, id, next_id);
4576 if (result == id) {
4577 return next_id;
4578 }
4579 }
4580 }
4581
4582 void VM_RedefineClasses::dump_methods() {
4583 int j;
4584 log_trace(redefine, class, dump)("_old_methods --");
4585 for (j = 0; j < _old_methods->length(); ++j) {
4586 LogStreamHandle(Trace, redefine, class, dump) log_stream;
4587 Method* m = _old_methods->at(j);
4588 log_stream.print("%4d (%5d) ", j, m->vtable_index());
4589 m->access_flags().print_on(&log_stream);
4590 log_stream.print(" -- ");
4591 m->print_name(&log_stream);
4592 log_stream.cr();
4593 }
4594 log_trace(redefine, class, dump)("_new_methods --");
4595 for (j = 0; j < _new_methods->length(); ++j) {
4596 LogStreamHandle(Trace, redefine, class, dump) log_stream;
4597 Method* m = _new_methods->at(j);
4598 log_stream.print("%4d (%5d) ", j, m->vtable_index());
4599 m->access_flags().print_on(&log_stream);
4600 log_stream.print(" -- ");
4601 m->print_name(&log_stream);
4602 log_stream.cr();
4603 }
4604 log_trace(redefine, class, dump)("_matching_methods --");
4605 for (j = 0; j < _matching_methods_length; ++j) {
4606 LogStreamHandle(Trace, redefine, class, dump) log_stream;
4607 Method* m = _matching_old_methods[j];
4608 log_stream.print("%4d (%5d) ", j, m->vtable_index());
4609 m->access_flags().print_on(&log_stream);
4610 log_stream.print(" -- ");
4611 m->print_name();
4612 log_stream.cr();
4613
4614 m = _matching_new_methods[j];
4615 log_stream.print(" (%5d) ", m->vtable_index());
4616 m->access_flags().print_on(&log_stream);
4617 log_stream.cr();
4618 }
4619 log_trace(redefine, class, dump)("_deleted_methods --");
4620 for (j = 0; j < _deleted_methods_length; ++j) {
4621 LogStreamHandle(Trace, redefine, class, dump) log_stream;
4622 Method* m = _deleted_methods[j];
4623 log_stream.print("%4d (%5d) ", j, m->vtable_index());
4624 m->access_flags().print_on(&log_stream);
4625 log_stream.print(" -- ");
4626 m->print_name(&log_stream);
4627 log_stream.cr();
4628 }
4629 log_trace(redefine, class, dump)("_added_methods --");
4630 for (j = 0; j < _added_methods_length; ++j) {
4631 LogStreamHandle(Trace, redefine, class, dump) log_stream;
4632 Method* m = _added_methods[j];
4633 log_stream.print("%4d (%5d) ", j, m->vtable_index());
4634 m->access_flags().print_on(&log_stream);
4635 log_stream.print(" -- ");
4636 m->print_name(&log_stream);
4637 log_stream.cr();
4638 }
4639 }
4640
4641 void VM_RedefineClasses::print_on_error(outputStream* st) const {
4642 VM_Operation::print_on_error(st);
4643 if (_the_class != nullptr) {
4644 ResourceMark rm;
4645 st->print_cr(", redefining class %s", _the_class->external_name());
4646 }
4647 }