jdk-sandbox: comparison hotspot/src/share/vm/oops/instanceKlass.cpp

equal deleted inserted replaced

-:6a4902a969d3
+:b495d1cfe673
 #include "oops/method.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/symbol.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "prims/jvmtiRedefineClasses.hpp"
-#include "prims/jvmtiRedefineClassesTrace.hpp"
 #include "prims/jvmtiThreadState.hpp"
 #include "prims/methodComparator.hpp"
 #include "runtime/atomic.inline.hpp"
 #include "runtime/fieldDescriptor.hpp"
 #include "runtime/handles.inline.hpp"
 assert(new_method != NULL, "method_with_idnum() should not be NULL");
 assert(old_method != new_method, "sanity check");
 default_methods()->at_put(index, new_method);
-if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
+if (log_is_enabled(Info, redefine, class, update)) {
+ResourceMark rm;
 if (!(*trace_name_printed)) {
-// RC_TRACE_MESG macro has an embedded ResourceMark
+log_info(redefine, class, update)
-RC_TRACE_MESG(("adjust: klassname=%s default methods from name=%s",
+("adjust: klassname=%s default methods from name=%s",
-external_name(),
+external_name(), old_method->method_holder()->external_name());
-old_method->method_holder()->external_name()));
 *trace_name_printed = true;
 }
-RC_TRACE(0x00100000, ("default method update: %s(%s) ",
+log_debug(redefine, class, update, vtables)
-new_method->name()->as_C_string(),
+("default method update: %s(%s) ",
-new_method->signature()->as_C_string()));
+new_method->name()->as_C_string(), new_method->signature()->as_C_string());
 }
 }
 }
 }
 #endif // INCLUDE_JVMTI
 int deleted_count = 0;    // leave debugging breadcrumbs
 int live_count = 0;
 ClassLoaderData* loader_data = ik->class_loader_data();
 assert(loader_data != NULL, "should never be null");
-// RC_TRACE macro has an embedded ResourceMark
+ResourceMark rm;
-RC_TRACE(0x00000200, ("purge: %s: previous versions", ik->external_name()));
+log_trace(redefine, class, iklass, purge)("%s: previous versions", ik->external_name());
 // previous versions are linked together through the InstanceKlass
 InstanceKlass* pv_node = ik->previous_versions();
 InstanceKlass* last = ik;
 int version = 0;
 if (!pvcp->on_stack()) {
 // If the constant pool isn't on stack, none of the methods
 // are executing.  Unlink this previous_version.
 // The previous version InstanceKlass is on the ClassLoaderData deallocate list
 // so will be deallocated during the next phase of class unloading.
-RC_TRACE(0x00000200, ("purge: previous version " INTPTR_FORMAT " is dead",
+log_trace(redefine, class, iklass, purge)("previous version " INTPTR_FORMAT " is dead", p2i(pv_node));
-p2i(pv_node)));
 // For debugging purposes.
 pv_node->set_is_scratch_class();
 pv_node->class_loader_data()->add_to_deallocate_list(pv_node);
 pv_node = pv_node->previous_versions();
 last->link_previous_versions(pv_node);
 deleted_count++;
 version++;
 continue;
 } else {
-RC_TRACE(0x00000200, ("purge: previous version " INTPTR_FORMAT " is alive",
+log_trace(redefine, class, iklass, purge)("previous version " INTPTR_FORMAT " is alive", p2i(pv_node));
-p2i(pv_node)));
 assert(pvcp->pool_holder() != NULL, "Constant pool with no holder");
 guarantee (!loader_data->is_unloading(), "unloaded classes can't be on the stack");
 live_count++;
 }
 // Reset dead EMCP methods not to get breakpoints.
 // All methods are deallocated when all of the methods for this class are no
 // longer running.
 Array<Method*>* method_refs = pv_node->methods();
 if (method_refs != NULL) {
-RC_TRACE(0x00000200, ("purge: previous methods length=%d",
+log_trace(redefine, class, iklass, purge)("previous methods length=%d", method_refs->length());
-method_refs->length()));
 for (int j = 0; j < method_refs->length(); j++) {
 Method* method = method_refs->at(j);
 if (!method->on_stack()) {
 // no breakpoints for non-running methods
 method->set_running_emcp(false);
 }
 } else {
 assert (method->is_obsolete() || method->is_running_emcp(),
 "emcp method cannot run after emcp bit is cleared");
-// RC_TRACE macro has an embedded ResourceMark
+log_trace(redefine, class, iklass, purge)
-RC_TRACE(0x00000200,
 ("purge: %s(%s): prev method @%d in version @%d is alive",
-method->name()->as_C_string(),
+method->name()->as_C_string(), method->signature()->as_C_string(), j, version);
-method->signature()->as_C_string(), j, version));
 }
 }
 }
 // next previous version
 last = pv_node;
 pv_node = pv_node->previous_versions();
 version++;
 }
-RC_TRACE(0x00000200,
+log_trace(redefine, class, iklass, purge)
-("purge: previous version stats: live=%d, deleted=%d", live_count,
+("previous version stats: live=%d, deleted=%d",
-deleted_count));
+live_count, deleted_count);
 }
 }
 void InstanceKlass::mark_newly_obsolete_methods(Array<Method*>* old_methods,
 int emcp_method_count) {
 if (!method->is_obsolete() &&
 method->name() == m_name &&
 method->signature() == m_signature) {
 // The current RedefineClasses() call has made all EMCP
 // versions of this method obsolete so mark it as obsolete
-RC_TRACE(0x00000400,
+log_trace(redefine, class, iklass, add)
-("add: %s(%s): flush obsolete method @%d in version @%d",
+("%s(%s): flush obsolete method @%d in version @%d",
-m_name->as_C_string(), m_signature->as_C_string(), k, j));
+m_name->as_C_string(), m_signature->as_C_string(), k, j);
 method->set_is_obsolete();
 break;
 }
 }
 void InstanceKlass::add_previous_version(instanceKlassHandle scratch_class,
 int emcp_method_count) {
 assert(Thread::current()->is_VM_thread(),
 "only VMThread can add previous versions");
-// RC_TRACE macro has an embedded ResourceMark
+ResourceMark rm;
-RC_TRACE(0x00000400, ("adding previous version ref for %s, EMCP_cnt=%d",
+log_trace(redefine, class, iklass, add)
-scratch_class->external_name(), emcp_method_count));
+("adding previous version ref for %s, EMCP_cnt=%d", scratch_class->external_name(), emcp_method_count);
 // Clean out old previous versions
 purge_previous_versions(this);
 // Mark newly obsolete methods in remaining previous versions.  An EMCP method from
 // is not marked as being on the stack, then none of the methods
 // in this previous version of the class are on the stack so
 // we don't need to add this as a previous version.
 ConstantPool* cp_ref = scratch_class->constants();
 if (!cp_ref->on_stack()) {
-RC_TRACE(0x00000400, ("add: scratch class not added; no methods are running"));
+log_trace(redefine, class, iklass, add)("scratch class not added; no methods are running");
 // For debugging purposes.
 scratch_class->set_is_scratch_class();
 scratch_class->class_loader_data()->add_to_deallocate_list(scratch_class());
 // Update count for class unloading.
 _previous_version_count--;
 // and use this bit to set the is_running_emcp bit.
 // After the safepoint, the on_stack bit is cleared and the running emcp
 // method may exit.   If so, we would set a breakpoint in a method that
 // is never reached, but this won't be noticeable to the programmer.
 old_method->set_running_emcp(true);
-RC_TRACE(0x00000400, ("add: EMCP method %s is on_stack " INTPTR_FORMAT,
+log_trace(redefine, class, iklass, add)
-old_method->name_and_sig_as_C_string(), p2i(old_method)));
+("EMCP method %s is on_stack " INTPTR_FORMAT, old_method->name_and_sig_as_C_string(), p2i(old_method));
 } else if (!old_method->is_obsolete()) {
-RC_TRACE(0x00000400, ("add: EMCP method %s is NOT on_stack " INTPTR_FORMAT,
+log_trace(redefine, class, iklass, add)
-old_method->name_and_sig_as_C_string(), p2i(old_method)));
+("EMCP method %s is NOT on_stack " INTPTR_FORMAT, old_method->name_and_sig_as_C_string(), p2i(old_method));
 }
 }
 }
 // Add previous version if any methods are still running.
-RC_TRACE(0x00000400, ("add: scratch class added; one of its methods is on_stack"));
+log_trace(redefine, class, iklass, add)("scratch class added; one of its methods is on_stack");
 assert(scratch_class->previous_versions() == NULL, "shouldn't have a previous version");
 scratch_class->link_previous_versions(previous_versions());
 link_previous_versions(scratch_class());
 // Update count for class unloading.
 _previous_version_count++;

changeset 38259	b495d1cfe673
parent 38151	fffedc5e5cf8
child 38937	2bf3c37c4841