< prev index next >

src/share/vm/prims/jvmtiRedefineClasses.cpp

Print this page

        

@@ -56,11 +56,11 @@
 Method**  VM_RedefineClasses::_deleted_methods      = NULL;
 Method**  VM_RedefineClasses::_added_methods        = NULL;
 int         VM_RedefineClasses::_matching_methods_length = 0;
 int         VM_RedefineClasses::_deleted_methods_length  = 0;
 int         VM_RedefineClasses::_added_methods_length    = 0;
-Klass*      VM_RedefineClasses::_the_class_oop = NULL;
+Klass*      VM_RedefineClasses::_the_class = NULL;
 
 
 VM_RedefineClasses::VM_RedefineClasses(jint class_count,
                                        const jvmtiClassDefinition *class_defs,
                                        JvmtiClassLoadKind class_load_kind) {

@@ -225,12 +225,12 @@
   unlock_classes();
 
   // Free os::malloc allocated memory.
   os::free(_scratch_classes);
 
-  // Reset the_class_oop to null for error printing.
-  _the_class_oop = NULL;
+  // Reset the_class to null for error printing.
+  _the_class = NULL;
 
   if (log_is_enabled(Info, redefine, class, timer)) {
     // Used to have separate timers for "doit" and "all", but the timer
     // overhead skewed the measurements.
     jlong doit_time = _timer_rsc_phase1.milliseconds() +

@@ -655,12 +655,12 @@
   _operands_index_map_count = 0;
 } // end finalize_operands_merge()
 
 
 jvmtiError VM_RedefineClasses::compare_and_normalize_class_versions(
-             instanceKlassHandle the_class,
-             instanceKlassHandle scratch_class) {
+             InstanceKlass* the_class,
+             InstanceKlass* scratch_class) {
   int i;
 
   // Check superclasses, or rather their names, since superclasses themselves can be
   // requested to replace.
   // Check for NULL superclass first since this might be java.lang.Object

@@ -991,12 +991,12 @@
 
 
 jvmtiError VM_RedefineClasses::load_new_class_versions(TRAPS) {
 
   // For consistency allocate memory using os::malloc wrapper.
-  _scratch_classes = (Klass**)
-    os::malloc(sizeof(Klass*) * _class_count, mtClass);
+  _scratch_classes = (InstanceKlass**)
+    os::malloc(sizeof(InstanceKlass*) * _class_count, mtClass);
   if (_scratch_classes == NULL) {
     return JVMTI_ERROR_OUT_OF_MEMORY;
   }
   // Zero initialize the _scratch_classes array.
   for (int i = 0; i < _class_count; i++) {

@@ -1012,11 +1012,11 @@
   for (int i = 0; i < _class_count; i++) {
     // Create HandleMark so that any handles created while loading new class
     // versions are deleted. Constant pools are deallocated while merging
     // constant pools
     HandleMark hm(THREAD);
-    instanceKlassHandle the_class(THREAD, get_ik(_class_defs[i].klass));
+    InstanceKlass* the_class = get_ik(_class_defs[i].klass);
     Symbol*  the_class_sym = the_class->name();
 
     log_debug(redefine, class, load)
       ("loading name=%s kind=%d (avail_mem=" UINT64_FORMAT "K)",
        the_class->external_name(), _class_load_kind, os::available_memory() >> 10);

@@ -1030,28 +1030,27 @@
     Handle the_class_loader(THREAD, the_class->class_loader());
     Handle protection_domain(THREAD, the_class->protection_domain());
     // Set redefined class handle in JvmtiThreadState class.
     // This redefined class is sent to agent event handler for class file
     // load hook event.
-    state->set_class_being_redefined(&the_class, _class_load_kind);
+    state->set_class_being_redefined(the_class, _class_load_kind);
 
-    Klass* k = SystemDictionary::parse_stream(the_class_sym,
+    InstanceKlass* scratch_class = SystemDictionary::parse_stream(
+                                                      the_class_sym,
                                                 the_class_loader,
                                                 protection_domain,
                                                 &st,
                                                 THREAD);
     // Clear class_being_redefined just to be sure.
     state->clear_class_being_redefined();
 
     // TODO: if this is retransform, and nothing changed we can skip it
 
-    instanceKlassHandle scratch_class (THREAD, k);
-
     // Need to clean up allocated InstanceKlass if there's an error so assign
     // the result here. Caller deallocates all the scratch classes in case of
     // an error.
-    _scratch_classes[i] = k;
+    _scratch_classes[i] = scratch_class;
 
     if (HAS_PENDING_EXCEPTION) {
       Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
       log_info(redefine, class, load, exceptions)("parse_stream exception: '%s'", ex_name->as_C_string());
       CLEAR_PENDING_EXCEPTION;

@@ -1104,11 +1103,11 @@
       // Information about the_class and scratch_class is temporarily
       // recorded into jvmtiThreadState. This data is used to redirect
       // the_class to scratch_class in the JVM_* functions called by the
       // verifier. Please, refer to jvmtiThreadState.hpp for the detailed
       // description.
-      RedefineVerifyMark rvm(&the_class, &scratch_class, state);
+      RedefineVerifyMark rvm(the_class, scratch_class, state);
       Verifier::verify(
         scratch_class, Verifier::ThrowException, true, THREAD);
     }
 
     if (HAS_PENDING_EXCEPTION) {

@@ -1136,11 +1135,11 @@
     }
 
     if (VerifyMergedCPBytecodes) {
       // verify what we have done during constant pool merging
       {
-        RedefineVerifyMark rvm(&the_class, &scratch_class, state);
+        RedefineVerifyMark rvm(the_class, scratch_class, state);
         Verifier::verify(scratch_class, Verifier::ThrowException, true, THREAD);
       }
 
       if (HAS_PENDING_EXCEPTION) {
         Symbol* ex_name = PENDING_EXCEPTION->klass()->name();

@@ -1432,11 +1431,11 @@
 
 // Merge constant pools between the_class and scratch_class and
 // potentially rewrite bytecodes in scratch_class to use the merged
 // constant pool.
 jvmtiError VM_RedefineClasses::merge_cp_and_rewrite(
-             instanceKlassHandle the_class, instanceKlassHandle scratch_class,
+             InstanceKlass* the_class, InstanceKlass* scratch_class,
              TRAPS) {
   // worst case merged constant pool length is old and new combined
   int merge_cp_length = the_class->constants()->length()
         + scratch_class->constants()->length();
 

@@ -1481,11 +1480,11 @@
   _operands_index_map_count = 0;
   int operands_index_map_len = ConstantPool::operand_array_length(scratch_cp->operands());
   _operands_index_map_p = new intArray(operands_index_map_len, operands_index_map_len, -1);
 
   // reference to the cp holder is needed for copy_operands()
-  merge_cp->set_pool_holder(scratch_class());
+  merge_cp->set_pool_holder(scratch_class);
   bool result = merge_constant_pools(old_cp, scratch_cp, &merge_cp,
                   &merge_cp_length, THREAD);
   merge_cp->set_pool_holder(NULL);
 
   if (!result) {

@@ -1566,11 +1565,11 @@
   return JVMTI_ERROR_NONE;
 } // end merge_cp_and_rewrite()
 
 
 // Rewrite constant pool references in klass scratch_class.
-bool VM_RedefineClasses::rewrite_cp_refs(instanceKlassHandle scratch_class,
+bool VM_RedefineClasses::rewrite_cp_refs(InstanceKlass* scratch_class,
        TRAPS) {
 
   // rewrite constant pool references in the methods:
   if (!rewrite_cp_refs_in_methods(scratch_class, THREAD)) {
     // propagate failure back to caller

@@ -1653,11 +1652,11 @@
   return true;
 } // end rewrite_cp_refs()
 
 // Rewrite constant pool references in the methods.
 bool VM_RedefineClasses::rewrite_cp_refs_in_methods(
-       instanceKlassHandle scratch_class, TRAPS) {
+       InstanceKlass* scratch_class, TRAPS) {
 
   Array<Method*>* methods = scratch_class->methods();
 
   if (methods == NULL || methods->length() == 0) {
     // no methods so nothing to do

@@ -1832,11 +1831,11 @@
 } // end rewrite_cp_refs_in_method()
 
 
 // Rewrite constant pool references in the class_annotations field.
 bool VM_RedefineClasses::rewrite_cp_refs_in_class_annotations(
-       instanceKlassHandle scratch_class, TRAPS) {
+       InstanceKlass* scratch_class, TRAPS) {
 
   AnnotationArray* class_annotations = scratch_class->class_annotations();
   if (class_annotations == NULL || class_annotations->length() == 0) {
     // no class_annotations so nothing to do
     return true;

@@ -2122,11 +2121,11 @@
 } // end rewrite_cp_refs_in_element_value()
 
 
 // Rewrite constant pool references in a fields_annotations field.
 bool VM_RedefineClasses::rewrite_cp_refs_in_fields_annotations(
-       instanceKlassHandle scratch_class, TRAPS) {
+       InstanceKlass* scratch_class, TRAPS) {
 
   Array<AnnotationArray*>* fields_annotations = scratch_class->fields_annotations();
 
   if (fields_annotations == NULL || fields_annotations->length() == 0) {
     // no fields_annotations so nothing to do

@@ -2155,11 +2154,11 @@
 } // end rewrite_cp_refs_in_fields_annotations()
 
 
 // Rewrite constant pool references in a methods_annotations field.
 bool VM_RedefineClasses::rewrite_cp_refs_in_methods_annotations(
-       instanceKlassHandle scratch_class, TRAPS) {
+       InstanceKlass* scratch_class, TRAPS) {
 
   for (int i = 0; i < scratch_class->methods()->length(); i++) {
     Method* m = scratch_class->methods()->at(i);
     AnnotationArray* method_annotations = m->constMethod()->method_annotations();
 

@@ -2193,11 +2192,11 @@
 //     annotation annotations[num_annotations];
 //   } parameter_annotations[num_parameters];
 // }
 //
 bool VM_RedefineClasses::rewrite_cp_refs_in_methods_parameter_annotations(
-       instanceKlassHandle scratch_class, TRAPS) {
+       InstanceKlass* scratch_class, TRAPS) {
 
   for (int i = 0; i < scratch_class->methods()->length(); i++) {
     Method* m = scratch_class->methods()->at(i);
     AnnotationArray* method_parameter_annotations = m->constMethod()->parameter_annotations();
     if (method_parameter_annotations == NULL

@@ -2242,11 +2241,11 @@
 // methods_default_annotations_typeArray {
 //   element_value default_value;
 // }
 //
 bool VM_RedefineClasses::rewrite_cp_refs_in_methods_default_annotations(
-       instanceKlassHandle scratch_class, TRAPS) {
+       InstanceKlass* scratch_class, TRAPS) {
 
   for (int i = 0; i < scratch_class->methods()->length(); i++) {
     Method* m = scratch_class->methods()->at(i);
     AnnotationArray* method_default_annotations = m->constMethod()->default_annotations();
     if (method_default_annotations == NULL

@@ -2269,11 +2268,11 @@
 } // end rewrite_cp_refs_in_methods_default_annotations()
 
 
 // Rewrite constant pool references in a class_type_annotations field.
 bool VM_RedefineClasses::rewrite_cp_refs_in_class_type_annotations(
-       instanceKlassHandle scratch_class, TRAPS) {
+       InstanceKlass* scratch_class, TRAPS) {
 
   AnnotationArray* class_type_annotations = scratch_class->class_type_annotations();
   if (class_type_annotations == NULL || class_type_annotations->length() == 0) {
     // no class_type_annotations so nothing to do
     return true;

@@ -2287,11 +2286,11 @@
 } // end rewrite_cp_refs_in_class_type_annotations()
 
 
 // Rewrite constant pool references in a fields_type_annotations field.
 bool VM_RedefineClasses::rewrite_cp_refs_in_fields_type_annotations(
-       instanceKlassHandle scratch_class, TRAPS) {
+       InstanceKlass* scratch_class, TRAPS) {
 
   Array<AnnotationArray*>* fields_type_annotations = scratch_class->fields_type_annotations();
   if (fields_type_annotations == NULL || fields_type_annotations->length() == 0) {
     // no fields_type_annotations so nothing to do
     return true;

@@ -2319,11 +2318,11 @@
 } // end rewrite_cp_refs_in_fields_type_annotations()
 
 
 // Rewrite constant pool references in a methods_type_annotations field.
 bool VM_RedefineClasses::rewrite_cp_refs_in_methods_type_annotations(
-       instanceKlassHandle scratch_class, TRAPS) {
+       InstanceKlass* scratch_class, TRAPS) {
 
   for (int i = 0; i < scratch_class->methods()->length(); i++) {
     Method* m = scratch_class->methods()->at(i);
     AnnotationArray* method_type_annotations = m->constMethod()->type_annotations();
 

@@ -3072,11 +3071,11 @@
 // scratch_cp. If shrink is true, then scratch_cp_length elements
 // are copied from scratch_cp to a smaller constant pool and the
 // smaller constant pool is associated with scratch_class.
 void VM_RedefineClasses::set_new_constant_pool(
        ClassLoaderData* loader_data,
-       instanceKlassHandle scratch_class, constantPoolHandle scratch_cp,
+       InstanceKlass* scratch_class, constantPoolHandle scratch_cp,
        int scratch_cp_length, TRAPS) {
   assert(scratch_cp->length() >= scratch_cp_length, "sanity check");
 
   // scratch_cp is a merged constant pool and has enough space for a
   // worst case merge situation. We want to associate the minimum

@@ -3089,11 +3088,11 @@
   assert(version != 0, "sanity check");
   smaller_cp->set_version(version);
 
   // attach klass to new constant pool
   // reference to the cp holder is needed for copy_operands()
-  smaller_cp->set_pool_holder(scratch_class());
+  smaller_cp->set_pool_holder(scratch_class);
 
   scratch_cp->copy_cp_to(1, scratch_cp_length - 1, smaller_cp, 1, THREAD);
   if (HAS_PENDING_EXCEPTION) {
     // Exception is handled in the caller
     loader_data->add_to_deallocate_list(smaller_cp());

@@ -3266,15 +3265,15 @@
 void VM_RedefineClasses::AdjustCpoolCacheAndVtable::do_klass(Klass* k) {
 
   // This is a very busy routine. We don't want too much tracing
   // printed out.
   bool trace_name_printed = false;
-  InstanceKlass *the_class = InstanceKlass::cast(_the_class_oop);
+  InstanceKlass *the_class = InstanceKlass::cast(_the_class);
 
   // If the class being redefined is java.lang.Object, we need to fix all
   // array class vtables also
-  if (k->is_array_klass() && _the_class_oop == SystemDictionary::Object_klass()) {
+  if (k->is_array_klass() && _the_class == SystemDictionary::Object_klass()) {
     k->vtable()->adjust_method_entries(the_class, &trace_name_printed);
 
   } else if (k->is_instance_klass()) {
     HandleMark hm(_thread);
     InstanceKlass *ik = InstanceKlass::cast(k);

@@ -3289,12 +3288,11 @@
     // class loader can delegate to the bootstrap class loader.
     //
     // If the current class being redefined has a user-defined class
     // loader as its defining class loader, then we can skip all
     // classes loaded by the bootstrap class loader.
-    bool is_user_defined =
-           InstanceKlass::cast(_the_class_oop)->class_loader() != NULL;
+    bool is_user_defined = (_the_class->class_loader() != NULL);
     if (is_user_defined && ik->class_loader() == NULL) {
       return;
     }
 
     // Fix the vtable embedded in the_class and subclasses of the_class,

@@ -3309,13 +3307,13 @@
     // We also need to adjust any default method entries that are
     // not yet in the vtable, because the vtable setup is in progress.
     // This must be done after we adjust the default_methods and
     // default_vtable_indices for methods already in the vtable.
     // If redefining Unsafe, walk all the vtables looking for entries.
-    if (ik->vtable_length() > 0 && (_the_class_oop->is_interface()
-        || _the_class_oop == SystemDictionary::internal_Unsafe_klass()
-        || ik->is_subtype_of(_the_class_oop))) {
+    if (ik->vtable_length() > 0 && (_the_class->is_interface()
+        || _the_class == SystemDictionary::internal_Unsafe_klass()
+        || ik->is_subtype_of(_the_class))) {
       // ik->vtable() creates a wrapper object; rm cleans it up
       ResourceMark rm(_thread);
 
       ik->vtable()->adjust_method_entries(the_class, &trace_name_printed);
       ik->adjust_default_methods(the_class, &trace_name_printed);

@@ -3326,13 +3324,13 @@
     // we potentially have to fix the itable. If we are redefining an
     // interface, then we have to call adjust_method_entries() for
     // every InstanceKlass that has an itable since there isn't a
     // subclass relationship between an interface and an InstanceKlass.
     // If redefining Unsafe, walk all the itables looking for entries.
-    if (ik->itable_length() > 0 && (_the_class_oop->is_interface()
-        || _the_class_oop == SystemDictionary::internal_Unsafe_klass()
-        || ik->is_subclass_of(_the_class_oop))) {
+    if (ik->itable_length() > 0 && (_the_class->is_interface()
+        || _the_class == SystemDictionary::internal_Unsafe_klass()
+        || ik->is_subclass_of(_the_class))) {
       // ik->itable() creates a wrapper object; rm cleans it up
       ResourceMark rm(_thread);
 
       ik->itable()->adjust_method_entries(the_class, &trace_name_printed);
     }

@@ -3351,11 +3349,11 @@
     // updated. We can simply start with the previous version(s) in
     // that case.
     constantPoolHandle other_cp;
     ConstantPoolCache* cp_cache;
 
-    if (ik != _the_class_oop) {
+    if (ik != _the_class) {
       // this klass' constant pool cache may need adjustment
       other_cp = constantPoolHandle(ik->constants());
       cp_cache = other_cp->cache();
       if (cp_cache != NULL) {
         cp_cache->adjust_method_entries(the_class, &trace_name_printed);

@@ -3497,11 +3495,11 @@
       obsolete_count++;
 
       // obsolete methods need a unique idnum so they become new entries in
       // the jmethodID cache in InstanceKlass
       assert(old_method->method_idnum() == new_method->method_idnum(), "must match");
-      u2 num = InstanceKlass::cast(_the_class_oop)->next_method_idnum();
+      u2 num = InstanceKlass::cast(_the_class)->next_method_idnum();
       if (num != ConstMethod::UNSET_IDNUM) {
         old_method->set_method_idnum(num);
       }
 
       // With tracing we try not to "yack" too much. The position of

@@ -3561,11 +3559,11 @@
 // Simultaneous add and remove          1_m     ->  2_m
 // Same, caused by prefix removal only  3_2_1_m ->  3_2_m
 //
 class TransferNativeFunctionRegistration {
  private:
-  instanceKlassHandle the_class;
+  InstanceKlass* the_class;
   int prefix_count;
   char** prefixes;
 
   // Recursively search the binary tree of possibly prefixed method names.
   // Iteration could be used if all agents were well behaved. Full tree walk is

@@ -3576,11 +3574,11 @@
   // where 'prefix' is the prefix at that 'depth' (first prefix, second prefix,...)
   Method* search_prefix_name_space(int depth, char* name_str, size_t name_len,
                                      Symbol* signature) {
     TempNewSymbol name_symbol = SymbolTable::probe(name_str, (int)name_len);
     if (name_symbol != NULL) {
-      Method* method = the_class()->lookup_method(name_symbol, signature);
+      Method* method = the_class->lookup_method(name_symbol, signature);
       if (method != NULL) {
         // Even if prefixed, intermediate methods must exist.
         if (method->is_native()) {
           // Wahoo, we found a (possibly prefixed) version of the method, return it.
           return method;

@@ -3639,11 +3637,11 @@
   }
 
  public:
 
   // Construct a native method transfer processor for this class.
-  TransferNativeFunctionRegistration(instanceKlassHandle _the_class) {
+  TransferNativeFunctionRegistration(InstanceKlass* _the_class) {
     assert(SafepointSynchronize::is_at_safepoint(), "sanity check");
 
     the_class = _the_class;
     prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count);
   }

@@ -3666,11 +3664,11 @@
     }
   }
 };
 
 // Don't lose the association between a native method and its JNI function.
-void VM_RedefineClasses::transfer_old_native_function_registrations(instanceKlassHandle the_class) {
+void VM_RedefineClasses::transfer_old_native_function_registrations(InstanceKlass* the_class) {
   TransferNativeFunctionRegistration transfer(the_class);
   transfer.transfer_registrations(_deleted_methods, _deleted_methods_length);
   transfer.transfer_registrations(_matching_old_methods, _matching_methods_length);
 }
 

@@ -3687,17 +3685,17 @@
 // thrown away. As can_redefine_classes has been obtained then
 // all future compilations will record dependencies so second and
 // subsequent calls to RedefineClasses need only throw away code
 // that depends on the class.
 //
-void VM_RedefineClasses::flush_dependent_code(instanceKlassHandle k_h, TRAPS) {
+void VM_RedefineClasses::flush_dependent_code(InstanceKlass* ik, TRAPS) {
   assert_locked_or_safepoint(Compile_lock);
 
   // All dependencies have been recorded from startup or this is a second or
   // subsequent use of RedefineClasses
   if (JvmtiExport::all_dependencies_are_recorded()) {
-    CodeCache::flush_evol_dependents_on(k_h);
+    CodeCache::flush_evol_dependents_on(ik);
   } else {
     CodeCache::mark_all_nmethods_for_deoptimization();
 
     ResourceMark rm(THREAD);
     DeoptimizationMarker dm;

@@ -3773,12 +3771,12 @@
   assert(_matching_methods_length + _deleted_methods_length == _old_methods->length(), "sanity");
   assert(_matching_methods_length + _added_methods_length == _new_methods->length(), "sanity");
 }
 
 
-void VM_RedefineClasses::swap_annotations(instanceKlassHandle the_class,
-                                          instanceKlassHandle scratch_class) {
+void VM_RedefineClasses::swap_annotations(InstanceKlass* the_class,
+                                          InstanceKlass* scratch_class) {
   // Swap annotation fields values
   Annotations* old_annotations = the_class->annotations();
   the_class->set_annotations(scratch_class->annotations());
   scratch_class->set_annotations(old_annotations);
 }

@@ -3795,37 +3793,36 @@
 //      ClassLoaderDataGraph::classes_do() facility which only allows
 //      a helper method to be specified. The interesting parameters
 //      that we would like to pass to the helper method are saved in
 //      static global fields in the VM operation.
 void VM_RedefineClasses::redefine_single_class(jclass the_jclass,
-       Klass* scratch_class_oop, TRAPS) {
+       InstanceKlass* scratch_class, TRAPS) {
 
   HandleMark hm(THREAD);   // make sure handles from this call are freed
 
   if (log_is_enabled(Info, redefine, class, timer)) {
     _timer_rsc_phase1.start();
   }
 
-  instanceKlassHandle scratch_class(THREAD, scratch_class_oop);
-  instanceKlassHandle the_class(THREAD, get_ik(the_jclass));
+  InstanceKlass* the_class = get_ik(the_jclass);
 
   // Remove all breakpoints in methods of this class
   JvmtiBreakpoints& jvmti_breakpoints = JvmtiCurrentBreakpoints::get_jvmti_breakpoints();
-  jvmti_breakpoints.clearall_in_class_at_safepoint(the_class());
+  jvmti_breakpoints.clearall_in_class_at_safepoint(the_class);
 
   // Deoptimize all compiled code that depends on this class
   flush_dependent_code(the_class, THREAD);
 
   _old_methods = the_class->methods();
   _new_methods = scratch_class->methods();
-  _the_class_oop = the_class();
+  _the_class = the_class;
   compute_added_deleted_matching_methods();
   update_jmethod_ids();
 
   // Attach new constant pool to the original klass. The original
   // klass still refers to the old constant pool (for now).
-  scratch_class->constants()->set_pool_holder(the_class());
+  scratch_class->constants()->set_pool_holder(the_class);
 
 #if 0
   // In theory, with constant pool merging in place we should be able
   // to save space by using the new, merged constant pool in place of
   // the old constant pool(s). By "pool(s)" I mean the constant pool in

@@ -3851,17 +3848,16 @@
   // original constant pool.  In order for the new methods to work when they
   // become old methods, they need to keep their updated copy of the constant pool.
 
   {
     // walk all previous versions of the klass
-    InstanceKlass *ik = (InstanceKlass *)the_class();
+    InstanceKlass *ik = (InstanceKlass *)the_class;
     PreviousVersionWalker pvw(ik);
-    instanceKlassHandle ikh;
+    InstanceKlass* ik;
     do {
-      ikh = pvw.next_previous_version();
-      if (!ikh.is_null()) {
-        ik = ikh();
+      ik = pvw.next_previous_version();
+      if (ik != NULL) {
 
         // attach previous version of klass to the new constant pool
         ik->set_constants(scratch_class->constants());
 
         // Attach each method in the previous version of klass to the

@@ -3870,11 +3866,11 @@
         for (int i = prev_methods->length() - 1; i >= 0; i--) {
           Method* method = prev_methods->at(i);
           method->set_constants(scratch_class->constants());
         }
       }
-    } while (!ikh.is_null());
+    } while (ik != NULL);
   }
 #endif
 
   // Replace methods and constantpool
   the_class->set_methods(_new_methods);

@@ -4039,24 +4035,24 @@
 
   // JSR-292 support
   MemberNameTable* mnt = the_class->member_names();
   if (mnt != NULL) {
     bool trace_name_printed = false;
-    mnt->adjust_method_entries(the_class(), &trace_name_printed);
+    mnt->adjust_method_entries(the_class, &trace_name_printed);
   }
 
   if (the_class->oop_map_cache() != NULL) {
     // Flush references to any obsolete methods from the oop map cache
     // so that obsolete methods are not pinned.
     the_class->oop_map_cache()->flush_obsolete_entries();
   }
 
+  increment_class_counter((InstanceKlass *)the_class, THREAD);
   {
     ResourceMark rm(THREAD);
     // increment the classRedefinedCount field in the_class and in any
     // direct and indirect subclasses of the_class
-    increment_class_counter((InstanceKlass *)the_class(), THREAD);
     log_info(redefine, class, load)
       ("redefined name=%s, count=%d (avail_mem=" UINT64_FORMAT "K)",
        the_class->external_name(), java_lang_Class::classRedefinedCount(the_class->java_mirror()), os::available_memory() >> 10);
     Events::log_redefinition(THREAD, "redefined class name=%s, count=%d",
                              the_class->external_name(),

@@ -4073,12 +4069,12 @@
   oop class_mirror = ik->java_mirror();
   Klass* class_oop = java_lang_Class::as_Klass(class_mirror);
   int new_count = java_lang_Class::classRedefinedCount(class_mirror) + 1;
   java_lang_Class::set_classRedefinedCount(class_mirror, new_count);
 
-  if (class_oop != _the_class_oop) {
-    // _the_class_oop count is printed at end of redefine_single_class()
+  if (class_oop != _the_class) {
+    // _the_class count is printed at end of redefine_single_class()
     log_debug(redefine, class, subclass)("updated count in subclass=%s to %d", ik->external_name(), new_count);
   }
 
   for (Klass *subk = ik->subklass(); subk != NULL;
        subk = subk->next_sibling()) {

@@ -4210,10 +4206,10 @@
   }
 }
 
 void VM_RedefineClasses::print_on_error(outputStream* st) const {
   VM_Operation::print_on_error(st);
-  if (_the_class_oop != NULL) {
+  if (_the_class != NULL) {
     ResourceMark rm;
-    st->print_cr(", redefining class %s", _the_class_oop->external_name());
+    st->print_cr(", redefining class %s", _the_class->external_name());
   }
 }
< prev index next >