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