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