jdk-sandbox: comparison hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp

equal deleted inserted replaced

-:6a4902a969d3
+:b495d1cfe673
 #include "code/codeCache.hpp"
 #include "compiler/compileBroker.hpp"
 #include "gc/shared/gcLocker.hpp"
 #include "interpreter/oopMapCache.hpp"
 #include "interpreter/rewriter.hpp"
+#include "logging/logStream.hpp"
 #include "memory/metadataFactory.hpp"
 #include "memory/metaspaceShared.hpp"
 #include "memory/resourceArea.hpp"
 #include "memory/universe.inline.hpp"
 #include "oops/fieldStreams.hpp"
 }
 }
 // Start timer after all the sanity checks; not quite accurate, but
 // better than adding a bunch of stop() calls.
-RC_TIMER_START(_timer_vm_op_prologue);
+if (log_is_enabled(Info, redefine, class, timer)) {
+_timer_vm_op_prologue.start();
+}
 // We first load new class versions in the prologue, because somewhere down the
 // call chain it is required that the current thread is a Java thread.
 _res = load_new_class_versions(Thread::current());
 if (_res != JVMTI_ERROR_NONE) {
 cld->add_to_deallocate_list(InstanceKlass::cast(_scratch_classes[i]));
 }
 }
 // Free os::malloc allocated memory in load_new_class_version.
 os::free(_scratch_classes);
-RC_TIMER_STOP(_timer_vm_op_prologue);
+_timer_vm_op_prologue.stop();
 return false;
 }
-RC_TIMER_STOP(_timer_vm_op_prologue);
+_timer_vm_op_prologue.stop();
 return true;
 }
 void VM_RedefineClasses::doit() {
 Thread *thread = Thread::current();
 // Sharing is enabled so we remap the shared readonly space to
 // shared readwrite, private just in case we need to redefine
 // a shared class. We do the remap during the doit() phase of
 // the safepoint to be safer.
 if (!MetaspaceShared::remap_shared_readonly_as_readwrite()) {
-RC_TRACE_WITH_THREAD(0x00000001, thread,
+log_info(redefine, class, load)("failed to remap shared readonly space to readwrite, private");
-("failed to remap shared readonly space to readwrite, private"));
 _res = JVMTI_ERROR_INTERNAL;
 return;
 }
 }
 JvmtiExport::set_has_redefined_a_class();
 // check_class() is optionally called for product bits, but is
 // always called for non-product bits.
 #ifdef PRODUCT
-if (RC_TRACE_ENABLED(0x00004000)) {
+if (log_is_enabled(Trace, redefine, class, obsolete, metadata)) {
 #endif
-RC_TRACE_WITH_THREAD(0x00004000, thread, ("calling check_class"));
+log_trace(redefine, class, obsolete, metadata)("calling check_class");
 CheckClass check_class(thread);
 ClassLoaderDataGraph::classes_do(&check_class);
 #ifdef PRODUCT
 }
 #endif
 os::free(_scratch_classes);
 // Reset the_class_oop to null for error printing.
 _the_class_oop = NULL;
-if (RC_TRACE_ENABLED(0x00000004)) {
+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() +
 _timer_rsc_phase2.milliseconds();
 jlong all_time = _timer_vm_op_prologue.milliseconds() + doit_time;
-RC_TRACE(0x00000004, ("vm_op: all=" UINT64_FORMAT
+log_info(redefine, class, timer)
-"  prologue=" UINT64_FORMAT "  doit=" UINT64_FORMAT, all_time,
+("vm_op: all=" UINT64_FORMAT "  prologue=" UINT64_FORMAT "  doit=" UINT64_FORMAT,
-_timer_vm_op_prologue.milliseconds(), doit_time));
+all_time, _timer_vm_op_prologue.milliseconds(), doit_time);
-RC_TRACE(0x00000004,
+log_info(redefine, class, timer)
 ("redefine_single_class: phase1=" UINT64_FORMAT "  phase2=" UINT64_FORMAT,
-_timer_rsc_phase1.milliseconds(), _timer_rsc_phase2.milliseconds()));
+_timer_rsc_phase1.milliseconds(), _timer_rsc_phase2.milliseconds());
 }
 }
 bool VM_RedefineClasses::is_modifiable_class(oop klass_mirror) {
 // classes for primitives cannot be redefined
 // If the referenced entries already exist in *merge_cp_p, then
 // both new_name_ref_i and new_signature_ref_i will both be 0.
 // In that case, all we are appending is the current entry.
 if (new_name_ref_i != name_ref_i) {
-RC_TRACE(0x00080000,
+log_trace(redefine, class, constantpool)
 ("NameAndType entry@%d name_ref_index change: %d to %d",
-*merge_cp_length_p, name_ref_i, new_name_ref_i));
+*merge_cp_length_p, name_ref_i, new_name_ref_i);
 }
 if (new_signature_ref_i != signature_ref_i) {
-RC_TRACE(0x00080000,
+log_trace(redefine, class, constantpool)
 ("NameAndType entry@%d signature_ref_index change: %d to %d",
-*merge_cp_length_p, signature_ref_i, new_signature_ref_i));
+*merge_cp_length_p, signature_ref_i, new_signature_ref_i);
 }
 (*merge_cp_p)->name_and_type_at_put(*merge_cp_length_p,
 new_name_ref_i, new_signature_ref_i);
 if (scratch_i != *merge_cp_length_p) {
 guarantee(false, "bad switch");
 break;
 }
 if (klass_ref_i != new_klass_ref_i) {
-RC_TRACE(0x00080000, ("%s entry@%d class_index changed: %d to %d",
+log_trace(redefine, class, constantpool)
-entry_name, *merge_cp_length_p, klass_ref_i, new_klass_ref_i));
+("%s entry@%d class_index changed: %d to %d", entry_name, *merge_cp_length_p, klass_ref_i, new_klass_ref_i);
 }
 if (name_and_type_ref_i != new_name_and_type_ref_i) {
-RC_TRACE(0x00080000,
+log_trace(redefine, class, constantpool)
 ("%s entry@%d name_and_type_index changed: %d to %d",
-entry_name, *merge_cp_length_p, name_and_type_ref_i,
+entry_name, *merge_cp_length_p, name_and_type_ref_i, new_name_and_type_ref_i);
-new_name_and_type_ref_i));
 }
 if (scratch_i != *merge_cp_length_p) {
 // The new entry in *merge_cp_p is at a different index than
 // the new entry in scratch_cp so we need to map the index values.
 {
 int ref_i = scratch_cp->method_type_index_at(scratch_i);
 int new_ref_i = find_or_append_indirect_entry(scratch_cp, ref_i, merge_cp_p,
 merge_cp_length_p, THREAD);
 if (new_ref_i != ref_i) {
-RC_TRACE(0x00080000,
+log_trace(redefine, class, constantpool)
-("MethodType entry@%d ref_index change: %d to %d",
+("MethodType entry@%d ref_index change: %d to %d", *merge_cp_length_p, ref_i, new_ref_i);
-*merge_cp_length_p, ref_i, new_ref_i));
 }
 (*merge_cp_p)->method_type_index_at_put(*merge_cp_length_p, new_ref_i);
 if (scratch_i != *merge_cp_length_p) {
 // The new entry in *merge_cp_p is at a different index than
 // the new entry in scratch_cp so we need to map the index values.
 int ref_kind = scratch_cp->method_handle_ref_kind_at(scratch_i);
 int ref_i = scratch_cp->method_handle_index_at(scratch_i);
 int new_ref_i = find_or_append_indirect_entry(scratch_cp, ref_i, merge_cp_p,
 merge_cp_length_p, THREAD);
 if (new_ref_i != ref_i) {
-RC_TRACE(0x00080000,
+log_trace(redefine, class, constantpool)
-("MethodHandle entry@%d ref_index change: %d to %d",
+("MethodHandle entry@%d ref_index change: %d to %d", *merge_cp_length_p, ref_i, new_ref_i);
-*merge_cp_length_p, ref_i, new_ref_i));
 }
 (*merge_cp_p)->method_handle_index_at_put(*merge_cp_length_p, ref_kind, new_ref_i);
 if (scratch_i != *merge_cp_length_p) {
 // The new entry in *merge_cp_p is at a different index than
 // the new entry in scratch_cp so we need to map the index values.
 // The bootstrap method NameAndType_info index
 int old_ref_i = scratch_cp->invoke_dynamic_name_and_type_ref_index_at(scratch_i);
 int new_ref_i = find_or_append_indirect_entry(scratch_cp, old_ref_i, merge_cp_p,
 merge_cp_length_p, THREAD);
 if (new_bs_i != old_bs_i) {
-RC_TRACE(0x00080000,
+log_trace(redefine, class, constantpool)
 ("InvokeDynamic entry@%d bootstrap_method_attr_index change: %d to %d",
-*merge_cp_length_p, old_bs_i, new_bs_i));
+*merge_cp_length_p, old_bs_i, new_bs_i);
 }
 if (new_ref_i != old_ref_i) {
-RC_TRACE(0x00080000,
+log_trace(redefine, class, constantpool)
-("InvokeDynamic entry@%d name_and_type_index change: %d to %d",
+("InvokeDynamic entry@%d name_and_type_index change: %d to %d", *merge_cp_length_p, old_ref_i, new_ref_i);
-*merge_cp_length_p, old_ref_i, new_ref_i));
 }
 (*merge_cp_p)->invoke_dynamic_at_put(*merge_cp_length_p, new_bs_i, new_ref_i);
 if (scratch_i != *merge_cp_length_p) {
 // The new entry in *merge_cp_p is at a different index than
 int old_ref_i = scratch_cp->operand_bootstrap_method_ref_index_at(old_bs_i);
 int new_ref_i = find_or_append_indirect_entry(scratch_cp, old_ref_i, merge_cp_p,
 merge_cp_length_p, THREAD);
 if (new_ref_i != old_ref_i) {
-RC_TRACE(0x00080000,
+log_trace(redefine, class, constantpool)
-("operands entry@%d bootstrap method ref_index change: %d to %d",
+("operands entry@%d bootstrap method ref_index change: %d to %d", _operands_cur_length, old_ref_i, new_ref_i);
-_operands_cur_length, old_ref_i, new_ref_i));
 }
 Array<u2>* merge_ops = (*merge_cp_p)->operands();
 int new_bs_i = _operands_cur_length;
 // We have _operands_cur_length == 0 when the merge_cp operands is empty yet.
 int old_arg_ref_i = scratch_cp->operand_argument_index_at(old_bs_i, i);
 int new_arg_ref_i = find_or_append_indirect_entry(scratch_cp, old_arg_ref_i, merge_cp_p,
 merge_cp_length_p, THREAD);
 merge_ops->at_put(new_base++, new_arg_ref_i);
 if (new_arg_ref_i != old_arg_ref_i) {
-RC_TRACE(0x00080000,
+log_trace(redefine, class, constantpool)
 ("operands entry@%d bootstrap method argument ref_index change: %d to %d",
-_operands_cur_length, old_arg_ref_i, new_arg_ref_i));
+_operands_cur_length, old_arg_ref_i, new_arg_ref_i);
 }
 }
 if (old_bs_i != _operands_cur_length) {
 // The bootstrap specifier in *merge_cp_p is at a different index than
 // that in scratch_cp so we need to map the index values.
 return;
 }
 // Shrink the merge_cp operands
 merge_cp->shrink_operands(_operands_cur_length, CHECK);
-if (RC_TRACE_ENABLED(0x00040000)) {
+if (log_is_enabled(Trace, redefine, class, constantpool)) {
 // don't want to loop unless we are tracing
 int count = 0;
 for (int i = 1; i < _operands_index_map_p->length(); i++) {
 int value = _operands_index_map_p->at(i);
 if (value != -1) {
-RC_TRACE_WITH_THREAD(0x00040000, THREAD,
+log_trace(redefine, class, constantpool)("operands_index_map[%d]: old=%d new=%d", count, i, value);
-("operands_index_map[%d]: old=%d new=%d", count, i, value));
 count++;
 }
 }
 }
 // Clean-up
 if (thread->has_pending_exception()) {
 return JVMTI_ERROR_OUT_OF_MEMORY;
 }
 }
 }
-RC_TRACE(0x00008000, ("Method matched: new: %s [%d] == old: %s [%d]",
+log_trace(redefine, class, normalize)
-k_new_method->name_and_sig_as_C_string(), ni,
+("Method matched: new: %s [%d] == old: %s [%d]",
-k_old_method->name_and_sig_as_C_string(), oi));
+k_new_method->name_and_sig_as_C_string(), ni, k_old_method->name_and_sig_as_C_string(), oi);
 // advance to next pair of methods
 ++oi;
 ++ni;
 break;
 case added:
 k_new_method->set_orig_method_idnum(num);
 if (thread->has_pending_exception()) {
 return JVMTI_ERROR_OUT_OF_MEMORY;
 }
 }
-RC_TRACE(0x00008000, ("Method added: new: %s [%d]",
+log_trace(redefine, class, normalize)
-k_new_method->name_and_sig_as_C_string(), ni));
+("Method added: new: %s [%d]", k_new_method->name_and_sig_as_C_string(), ni);
 ++ni; // advance to next new method
 break;
 case deleted:
 // method deleted, see if it is OK
 old_flags = (jushort) k_old_method->access_flags().get_flags();
 || (old_flags & (JVM_ACC_FINAL|JVM_ACC_STATIC)) == 0
 ) {
 // deleted methods must be private
 return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED;
 }
-RC_TRACE(0x00008000, ("Method deleted: old: %s [%d]",
+log_trace(redefine, class, normalize)
-k_old_method->name_and_sig_as_C_string(), oi));
+("Method deleted: old: %s [%d]", k_old_method->name_and_sig_as_C_string(), oi);
 ++oi; // advance to next old method
 break;
 default:
 ShouldNotReachHere();
 }
 }
 Klass* the_class_oop = java_lang_Class::as_Klass(mirror);
 instanceKlassHandle the_class = instanceKlassHandle(THREAD, the_class_oop);
 Symbol*  the_class_sym = the_class->name();
-// RC_TRACE_WITH_THREAD macro has an embedded ResourceMark
+log_debug(redefine, class, load)
-RC_TRACE_WITH_THREAD(0x00000001, THREAD,
 ("loading name=%s kind=%d (avail_mem=" UINT64_FORMAT "K)",
-the_class->external_name(), _class_load_kind,
+the_class->external_name(), _class_load_kind, os::available_memory() >> 10);
-os::available_memory() >> 10));
 ClassFileStream st((u1*)_class_defs[i].class_bytes,
 _class_defs[i].class_byte_count,
 "__VM_RedefineClasses__",
 ClassFileStream::verify);
 // an error.
 _scratch_classes[i] = k;
 if (HAS_PENDING_EXCEPTION) {
 Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
-// RC_TRACE_WITH_THREAD macro has an embedded ResourceMark
+log_info(redefine, class, load, exceptions)("parse_stream exception: '%s'", ex_name->as_C_string());
-RC_TRACE_WITH_THREAD(0x00000002, THREAD, ("parse_stream exception: '%s'",
-ex_name->as_C_string()));
 CLEAR_PENDING_EXCEPTION;
 if (ex_name == vmSymbols::java_lang_UnsupportedClassVersionError()) {
 return JVMTI_ERROR_UNSUPPORTED_VERSION;
 } else if (ex_name == vmSymbols::java_lang_ClassFormatError()) {
 // Ensure class is linked before redefine
 if (!the_class->is_linked()) {
 the_class->link_class(THREAD);
 if (HAS_PENDING_EXCEPTION) {
 Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
-// RC_TRACE_WITH_THREAD macro has an embedded ResourceMark
+log_info(redefine, class, load, exceptions)("link_class exception: '%s'", ex_name->as_C_string());
-RC_TRACE_WITH_THREAD(0x00000002, THREAD, ("link_class exception: '%s'",
-ex_name->as_C_string()));
 CLEAR_PENDING_EXCEPTION;
 if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) {
 return JVMTI_ERROR_OUT_OF_MEMORY;
 } else {
 return JVMTI_ERROR_INTERNAL;
 scratch_class, Verifier::ThrowException, true, THREAD);
 }
 if (HAS_PENDING_EXCEPTION) {
 Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
-// RC_TRACE_WITH_THREAD macro has an embedded ResourceMark
+log_info(redefine, class, load, exceptions)("verify_byte_codes exception: '%s'", ex_name->as_C_string());
-RC_TRACE_WITH_THREAD(0x00000002, THREAD,
-("verify_byte_codes exception: '%s'", ex_name->as_C_string()));
 CLEAR_PENDING_EXCEPTION;
 if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) {
 return JVMTI_ERROR_OUT_OF_MEMORY;
 } else {
 // tell the caller the bytecodes are bad
 }
 res = merge_cp_and_rewrite(the_class, scratch_class, THREAD);
 if (HAS_PENDING_EXCEPTION) {
 Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
-// RC_TRACE_WITH_THREAD macro has an embedded ResourceMark
+log_info(redefine, class, load, exceptions)("merge_cp_and_rewrite exception: '%s'", ex_name->as_C_string());
-RC_TRACE_WITH_THREAD(0x00000002, THREAD,
-("merge_cp_and_rewrite exception: '%s'", ex_name->as_C_string()));
 CLEAR_PENDING_EXCEPTION;
 if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) {
 return JVMTI_ERROR_OUT_OF_MEMORY;
 } else {
 return JVMTI_ERROR_INTERNAL;
 Verifier::verify(scratch_class, Verifier::ThrowException, true, THREAD);
 }
 if (HAS_PENDING_EXCEPTION) {
 Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
-// RC_TRACE_WITH_THREAD macro has an embedded ResourceMark
+log_info(redefine, class, load, exceptions)
-RC_TRACE_WITH_THREAD(0x00000002, THREAD,
+("verify_byte_codes post merge-CP exception: '%s'", ex_name->as_C_string());
-("verify_byte_codes post merge-CP exception: '%s'",
-ex_name->as_C_string()));
 CLEAR_PENDING_EXCEPTION;
 if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) {
 return JVMTI_ERROR_OUT_OF_MEMORY;
 } else {
 // tell the caller that constant pool merging screwed up
 if (!HAS_PENDING_EXCEPTION) {
 scratch_class->link_methods(THREAD);
 }
 if (HAS_PENDING_EXCEPTION) {
 Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
-// RC_TRACE_WITH_THREAD macro has an embedded ResourceMark
+log_info(redefine, class, load, exceptions)
-RC_TRACE_WITH_THREAD(0x00000002, THREAD,
+("Rewriter::rewrite or link_methods exception: '%s'", ex_name->as_C_string());
-("Rewriter::rewrite or link_methods exception: '%s'", ex_name->as_C_string()));
 CLEAR_PENDING_EXCEPTION;
 if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) {
 return JVMTI_ERROR_OUT_OF_MEMORY;
 } else {
 return JVMTI_ERROR_INTERNAL;
 }
 }
-// RC_TRACE_WITH_THREAD macro has an embedded ResourceMark
+log_debug(redefine, class, load)
-RC_TRACE_WITH_THREAD(0x00000001, THREAD,
+("loaded name=%s (avail_mem=" UINT64_FORMAT "K)", the_class->external_name(), os::available_memory() >> 10);
-("loaded name=%s (avail_mem=" UINT64_FORMAT "K)",
-the_class->external_name(), os::available_memory() >> 10));
 }
 return JVMTI_ERROR_NONE;
 }
 // Map old_index to new_index as needed. scratch_cp is only needed
-// for RC_TRACE() calls.
+// for log calls.
 void VM_RedefineClasses::map_index(const constantPoolHandle& scratch_cp,
 int old_index, int new_index) {
 if (find_new_index(old_index) != 0) {
 // old_index is already mapped
 return;
 }
 _index_map_p->at_put(old_index, new_index);
 _index_map_count++;
-RC_TRACE(0x00040000, ("mapped tag %d at index %d to %d",
+log_trace(redefine, class, constantpool)
-scratch_cp->tag_at(old_index).value(), old_index, new_index));
+("mapped tag %d at index %d to %d", scratch_cp->tag_at(old_index).value(), old_index, new_index);
 } // end map_index()
 // Map old_index to new_index as needed.
 void VM_RedefineClasses::map_operand_index(int old_index, int new_index) {
 }
 _operands_index_map_p->at_put(old_index, new_index);
 _operands_index_map_count++;
-RC_TRACE(0x00040000, ("mapped bootstrap specifier at index %d to %d", old_index, new_index));
+log_trace(redefine, class, constantpool)("mapped bootstrap specifier at index %d to %d", old_index, new_index);
 } // end map_index()
 // Merge old_cp and scratch_cp and return the results of the merge via
 // merge_cp_p. The number of entries in *merge_cp_p is returned via
 if ((*merge_cp_p)->length() < old_cp->length()) {
 assert(false, "merge area too small");
 return false; // robustness
 }
-RC_TRACE_WITH_THREAD(0x00010000, THREAD,
+log_info(redefine, class, constantpool)("old_cp_len=%d, scratch_cp_len=%d", old_cp->length(), scratch_cp->length());
-("old_cp_len=%d, scratch_cp_len=%d", old_cp->length(),
-scratch_cp->length()));
 {
 // Pass 0:
 // The old_cp is copied to *merge_cp_p; this means that any code
 // using old_cp does not have to change. This work looks like a
 (*merge_cp_length_p) = old_i;
 }
 // merge_cp_len should be the same as old_cp->length() at this point
 // so this trace message is really a "warm-and-breathing" message.
-RC_TRACE_WITH_THREAD(0x00020000, THREAD,
+log_debug(redefine, class, constantpool)("after pass 0: merge_cp_len=%d", *merge_cp_length_p);
-("after pass 0: merge_cp_len=%d", *merge_cp_length_p));
 int scratch_i;  // index into scratch_cp
 {
 // Pass 1a:
 // Compare scratch_cp entries to the old_cp entries that we have
 append_entry(scratch_cp, scratch_i, merge_cp_p, merge_cp_length_p,
 CHECK_0);
 }
 }
-RC_TRACE_WITH_THREAD(0x00020000, THREAD,
+log_debug(redefine, class, constantpool)
 ("after pass 1a: merge_cp_len=%d, scratch_i=%d, index_map_len=%d",
-*merge_cp_length_p, scratch_i, _index_map_count));
+*merge_cp_length_p, scratch_i, _index_map_count);
 if (scratch_i < scratch_cp->length()) {
 // Pass 1b:
 // old_cp is smaller than scratch_cp so there are entries in
 // scratch_cp that we have not yet processed. We take care of
 // referenced entries to *merge_cp_p.
 append_entry(scratch_cp, scratch_i, merge_cp_p, merge_cp_length_p,
 CHECK_0);
 }
-RC_TRACE_WITH_THREAD(0x00020000, THREAD,
+log_debug(redefine, class, constantpool)
 ("after pass 1b: merge_cp_len=%d, scratch_i=%d, index_map_len=%d",
-*merge_cp_length_p, scratch_i, _index_map_count));
+*merge_cp_length_p, scratch_i, _index_map_count);
 }
 finalize_operands_merge(*merge_cp_p, THREAD);
 return true;
 } // end merge_constant_pools()
 // The merge can fail due to memory allocation failure or due
 // to robustness checks.
 return JVMTI_ERROR_INTERNAL;
 }
-RC_TRACE_WITH_THREAD(0x00010000, THREAD,
+log_info(redefine, class, constantpool)("merge_cp_len=%d, index_map_len=%d", merge_cp_length, _index_map_count);
-("merge_cp_len=%d, index_map_len=%d", merge_cp_length, _index_map_count));
 if (_index_map_count == 0) {
 // there is nothing to map between the new and merged constant pools
 if (old_cp->length() == scratch_cp->length()) {
 // The new constant pool replaces scratch_cp so have cleaner clean it up.
 // It can't be cleaned up while there are handles to it.
 cp_cleaner.add_scratch_cp(scratch_cp());
 }
 } else {
-if (RC_TRACE_ENABLED(0x00040000)) {
+if (log_is_enabled(Trace, redefine, class, constantpool)) {
 // don't want to loop unless we are tracing
 int count = 0;
 for (int i = 1; i < _index_map_p->length(); i++) {
 int value = _index_map_p->at(i);
 if (value != -1) {
-RC_TRACE_WITH_THREAD(0x00040000, THREAD,
+log_trace(redefine, class, constantpool)("index_map[%d]: old=%d new=%d", count, i, value);
-("index_map[%d]: old=%d new=%d", count, i, value));
 count++;
 }
 }
 }
 // deallocation list.
 methods->at_put(i, new_method());
 }
 if (HAS_PENDING_EXCEPTION) {
 Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
-// RC_TRACE_WITH_THREAD macro has an embedded ResourceMark
+log_info(redefine, class, load, exceptions)("rewrite_cp_refs_in_method exception: '%s'", ex_name->as_C_string());
-RC_TRACE_WITH_THREAD(0x00000002, THREAD,
-("rewrite_cp_refs_in_method exception: '%s'", ex_name->as_C_string()));
 // Need to clear pending exception here as the super caller sets
 // the JVMTI_ERROR_INTERNAL if the returned value is false.
 CLEAR_PENDING_EXCEPTION;
 return false;
 }
 if (new_index != 0) {
 // the original index is mapped so we have more work to do
 if (!StressLdcRewrite && new_index <= max_jubyte) {
 // The new value can still use ldc instead of ldc_w
 // unless we are trying to stress ldc -> ldc_w rewriting
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)
-("%s@" INTPTR_FORMAT " old=%d, new=%d", Bytecodes::name(c),
+("%s@" INTPTR_FORMAT " old=%d, new=%d", Bytecodes::name(c), p2i(bcp), cp_index, new_index);
-p2i(bcp), cp_index, new_index));
 *(bcp + 1) = new_index;
 } else {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)
-("%s->ldc_w@" INTPTR_FORMAT " old=%d, new=%d",
+("%s->ldc_w@" INTPTR_FORMAT " old=%d, new=%d", Bytecodes::name(c), p2i(bcp), cp_index, new_index);
-Bytecodes::name(c), p2i(bcp), cp_index, new_index));
 // the new value needs ldc_w instead of ldc
 u_char inst_buffer[4]; // max instruction size is 4 bytes
 bcp = (address)inst_buffer;
 // construct new instruction sequence
 *bcp = Bytecodes::_ldc_w;
 address p = bcp + 1;
 int cp_index = Bytes::get_Java_u2(p);
 int new_index = find_new_index(cp_index);
 if (new_index != 0) {
 // the original index is mapped so update w/ new value
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)
-("%s@" INTPTR_FORMAT " old=%d, new=%d", Bytecodes::name(c),
+("%s@" INTPTR_FORMAT " old=%d, new=%d", Bytecodes::name(c),p2i(bcp), cp_index, new_index);
-p2i(bcp), cp_index, new_index));
 // Rewriter::rewrite_method() uses put_native_u2() in this
 // situation because it is reusing the constant pool index
 // location for a native index into the ConstantPoolCache.
 // Since we are updating the constant pool index prior to
 // verification and ConstantPoolCache initialization, we
 if (class_annotations == NULL || class_annotations->length() == 0) {
 // no class_annotations so nothing to do
 return true;
 }
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("class_annotations length=%d", class_annotations->length());
-("class_annotations length=%d", class_annotations->length()));
 int byte_i = 0;  // byte index into class_annotations
 return rewrite_cp_refs_in_annotations_typeArray(class_annotations, byte_i,
 THREAD);
 }
 bool VM_RedefineClasses::rewrite_cp_refs_in_annotations_typeArray(
 AnnotationArray* annotations_typeArray, int &byte_i_ref, TRAPS) {
 if ((byte_i_ref + 2) > annotations_typeArray->length()) {
 // not enough room for num_annotations field
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for num_annotations field");
-("length() is too small for num_annotations field"));
 return false;
 }
 u2 num_annotations = Bytes::get_Java_u2((address)
 annotations_typeArray->adr_at(byte_i_ref));
 byte_i_ref += 2;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("num_annotations=%d", num_annotations);
-("num_annotations=%d", num_annotations));
 int calc_num_annotations = 0;
 for (; calc_num_annotations < num_annotations; calc_num_annotations++) {
 if (!rewrite_cp_refs_in_annotation_struct(annotations_typeArray,
 byte_i_ref, THREAD)) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("bad annotation_struct at %d", calc_num_annotations);
-("bad annotation_struct at %d", calc_num_annotations));
 // propagate failure back to caller
 return false;
 }
 }
 assert(num_annotations == calc_num_annotations, "sanity check");
 //
 bool VM_RedefineClasses::rewrite_cp_refs_in_annotation_struct(
 AnnotationArray* annotations_typeArray, int &byte_i_ref, TRAPS) {
 if ((byte_i_ref + 2 + 2) > annotations_typeArray->length()) {
 // not enough room for smallest annotation_struct
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for annotation_struct");
-("length() is too small for annotation_struct"));
 return false;
 }
 u2 type_index = rewrite_cp_ref_in_annotation_data(annotations_typeArray,
 byte_i_ref, "type_index", THREAD);
 u2 num_element_value_pairs = Bytes::get_Java_u2((address)
 annotations_typeArray->adr_at(byte_i_ref));
 byte_i_ref += 2;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)
-("type_index=%d  num_element_value_pairs=%d", type_index,
+("type_index=%d  num_element_value_pairs=%d", type_index, num_element_value_pairs);
-num_element_value_pairs));
 int calc_num_element_value_pairs = 0;
 for (; calc_num_element_value_pairs < num_element_value_pairs;
 calc_num_element_value_pairs++) {
 if ((byte_i_ref + 2) > annotations_typeArray->length()) {
 // not enough room for another element_name_index, let alone
 // the rest of another component
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for element_name_index");
-("length() is too small for element_name_index"));
 return false;
 }
 u2 element_name_index = rewrite_cp_ref_in_annotation_data(
 annotations_typeArray, byte_i_ref,
 "element_name_index", THREAD);
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("element_name_index=%d", element_name_index);
-("element_name_index=%d", element_name_index));
 if (!rewrite_cp_refs_in_element_value(annotations_typeArray,
 byte_i_ref, THREAD)) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("bad element_value at %d", calc_num_element_value_pairs);
-("bad element_value at %d", calc_num_element_value_pairs));
 // propagate failure back to caller
 return false;
 }
 } // end for each component
 assert(num_element_value_pairs == calc_num_element_value_pairs,
 address cp_index_addr = (address)
 annotations_typeArray->adr_at(byte_i_ref);
 u2 old_cp_index = Bytes::get_Java_u2(cp_index_addr);
 u2 new_cp_index = find_new_index(old_cp_index);
 if (new_cp_index != 0) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("mapped old %s=%d", trace_mesg, old_cp_index));
+log_debug(redefine, class, annotation)("mapped old %s=%d", trace_mesg, old_cp_index);
 Bytes::put_Java_u2(cp_index_addr, new_cp_index);
 old_cp_index = new_cp_index;
 }
 byte_i_ref += 2;
 return old_cp_index;
 bool VM_RedefineClasses::rewrite_cp_refs_in_element_value(
 AnnotationArray* annotations_typeArray, int &byte_i_ref, TRAPS) {
 if ((byte_i_ref + 1) > annotations_typeArray->length()) {
 // not enough room for a tag let alone the rest of an element_value
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a tag");
-("length() is too small for a tag"));
 return false;
 }
 u1 tag = annotations_typeArray->at(byte_i_ref);
 byte_i_ref++;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("tag='%c'", tag));
+log_debug(redefine, class, annotation)("tag='%c'", tag);
 switch (tag) {
 // These BaseType tag values are from Table 4.2 in VM spec:
 case 'B':  // byte
 case 'C':  // char
 // For the above tag values (including the BaseType values),
 // value.const_value_index is right union field.
 if ((byte_i_ref + 2) > annotations_typeArray->length()) {
 // not enough room for a const_value_index
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a const_value_index");
-("length() is too small for a const_value_index"));
 return false;
 }
 u2 const_value_index = rewrite_cp_ref_in_annotation_data(
 annotations_typeArray, byte_i_ref,
 "const_value_index", THREAD);
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("const_value_index=%d", const_value_index);
-("const_value_index=%d", const_value_index));
 } break;
 case 'e':
 {
 // for the above tag value, value.enum_const_value is right union field
 if ((byte_i_ref + 4) > annotations_typeArray->length()) {
 // not enough room for a enum_const_value
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a enum_const_value");
-("length() is too small for a enum_const_value"));
 return false;
 }
 u2 type_name_index = rewrite_cp_ref_in_annotation_data(
 annotations_typeArray, byte_i_ref,
 u2 const_name_index = rewrite_cp_ref_in_annotation_data(
 annotations_typeArray, byte_i_ref,
 "const_name_index", THREAD);
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)
-("type_name_index=%d  const_name_index=%d", type_name_index,
+("type_name_index=%d  const_name_index=%d", type_name_index, const_name_index);
-const_name_index));
 } break;
 case 'c':
 {
 // for the above tag value, value.class_info_index is right union field
 if ((byte_i_ref + 2) > annotations_typeArray->length()) {
 // not enough room for a class_info_index
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a class_info_index");
-("length() is too small for a class_info_index"));
 return false;
 }
 u2 class_info_index = rewrite_cp_ref_in_annotation_data(
 annotations_typeArray, byte_i_ref,
 "class_info_index", THREAD);
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("class_info_index=%d", class_info_index);
-("class_info_index=%d", class_info_index));
 } break;
 case '@':
 // For the above tag value, value.attr_value is the right union
 // field. This is a nested annotation.
 case '[':
 {
 if ((byte_i_ref + 2) > annotations_typeArray->length()) {
 // not enough room for a num_values field
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a num_values field");
-("length() is too small for a num_values field"));
 return false;
 }
 // For the above tag value, value.array_value is the right union
 // field. This is an array of nested element_value.
 u2 num_values = Bytes::get_Java_u2((address)
 annotations_typeArray->adr_at(byte_i_ref));
 byte_i_ref += 2;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("num_values=%d", num_values));
+log_debug(redefine, class, annotation)("num_values=%d", num_values);
 int calc_num_values = 0;
 for (; calc_num_values < num_values; calc_num_values++) {
 if (!rewrite_cp_refs_in_element_value(
 annotations_typeArray, byte_i_ref, THREAD)) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("bad nested element_value at %d", calc_num_values);
-("bad nested element_value at %d", calc_num_values));
 // propagate failure back to caller
 return false;
 }
 }
 assert(num_values == calc_num_values, "sanity check");
 } break;
 default:
-RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("bad tag=0x%x", tag));
+log_debug(redefine, class, annotation)("bad tag=0x%x", tag);
 return false;
 } // end decode tag field
 return true;
 } // end rewrite_cp_refs_in_element_value()
 if (fields_annotations == NULL || fields_annotations->length() == 0) {
 // no fields_annotations so nothing to do
 return true;
 }
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("fields_annotations length=%d", fields_annotations->length());
-("fields_annotations length=%d", fields_annotations->length()));
 for (int i = 0; i < fields_annotations->length(); i++) {
 AnnotationArray* field_annotations = fields_annotations->at(i);
 if (field_annotations == NULL || field_annotations->length() == 0) {
 // this field does not have any annotations so skip it
 }
 int byte_i = 0;  // byte index into field_annotations
 if (!rewrite_cp_refs_in_annotations_typeArray(field_annotations, byte_i,
 THREAD)) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("bad field_annotations at %d", i);
-("bad field_annotations at %d", i));
 // propagate failure back to caller
 return false;
 }
 }
 }
 int byte_i = 0;  // byte index into method_annotations
 if (!rewrite_cp_refs_in_annotations_typeArray(method_annotations, byte_i,
 THREAD)) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("bad method_annotations at %d", i);
-("bad method_annotations at %d", i));
 // propagate failure back to caller
 return false;
 }
 }
 continue;
 }
 if (method_parameter_annotations->length() < 1) {
 // not enough room for a num_parameters field
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a num_parameters field at %d", i);
-("length() is too small for a num_parameters field at %d", i));
 return false;
 }
 int byte_i = 0;  // byte index into method_parameter_annotations
 u1 num_parameters = method_parameter_annotations->at(byte_i);
 byte_i++;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("num_parameters=%d", num_parameters);
-("num_parameters=%d", num_parameters));
 int calc_num_parameters = 0;
 for (; calc_num_parameters < num_parameters; calc_num_parameters++) {
 if (!rewrite_cp_refs_in_annotations_typeArray(
 method_parameter_annotations, byte_i, THREAD)) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("bad method_parameter_annotations at %d", calc_num_parameters);
-("bad method_parameter_annotations at %d", calc_num_parameters));
 // propagate failure back to caller
 return false;
 }
 }
 assert(num_parameters == calc_num_parameters, "sanity check");
 int byte_i = 0;  // byte index into method_default_annotations
 if (!rewrite_cp_refs_in_element_value(
 method_default_annotations, byte_i, THREAD)) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("bad default element_value at %d", i);
-("bad default element_value at %d", i));
 // propagate failure back to caller
 return false;
 }
 }
 if (class_type_annotations == NULL || class_type_annotations->length() == 0) {
 // no class_type_annotations so nothing to do
 return true;
 }
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("class_type_annotations length=%d", class_type_annotations->length());
-("class_type_annotations length=%d", class_type_annotations->length()));
 int byte_i = 0;  // byte index into class_type_annotations
 return rewrite_cp_refs_in_type_annotations_typeArray(class_type_annotations,
 byte_i, "ClassFile", THREAD);
 } // end rewrite_cp_refs_in_class_type_annotations()
 if (fields_type_annotations == NULL || fields_type_annotations->length() == 0) {
 // no fields_type_annotations so nothing to do
 return true;
 }
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("fields_type_annotations length=%d", fields_type_annotations->length());
-("fields_type_annotations length=%d", fields_type_annotations->length()));
 for (int i = 0; i < fields_type_annotations->length(); i++) {
 AnnotationArray* field_type_annotations = fields_type_annotations->at(i);
 if (field_type_annotations == NULL || field_type_annotations->length() == 0) {
 // this field does not have any annotations so skip it
 }
 int byte_i = 0;  // byte index into field_type_annotations
 if (!rewrite_cp_refs_in_type_annotations_typeArray(field_type_annotations,
 byte_i, "field_info", THREAD)) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("bad field_type_annotations at %d", i);
-("bad field_type_annotations at %d", i));
 // propagate failure back to caller
 return false;
 }
 }
 if (method_type_annotations == NULL || method_type_annotations->length() == 0) {
 // this method does not have any annotations so skip it
 continue;
 }
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("methods type_annotations length=%d", method_type_annotations->length());
-("methods type_annotations length=%d", method_type_annotations->length()));
 int byte_i = 0;  // byte index into method_type_annotations
 if (!rewrite_cp_refs_in_type_annotations_typeArray(method_type_annotations,
 byte_i, "method_info", THREAD)) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("bad method_type_annotations at %d", i);
-("bad method_type_annotations at %d", i));
 // propagate failure back to caller
 return false;
 }
 }
 AnnotationArray* type_annotations_typeArray, int &byte_i_ref,
 const char * location_mesg, TRAPS) {
 if ((byte_i_ref + 2) > type_annotations_typeArray->length()) {
 // not enough room for num_annotations field
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for num_annotations field");
-("length() is too small for num_annotations field"));
 return false;
 }
 u2 num_annotations = Bytes::get_Java_u2((address)
 type_annotations_typeArray->adr_at(byte_i_ref));
 byte_i_ref += 2;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("num_type_annotations=%d", num_annotations);
-("num_type_annotations=%d", num_annotations));
 int calc_num_annotations = 0;
 for (; calc_num_annotations < num_annotations; calc_num_annotations++) {
 if (!rewrite_cp_refs_in_type_annotation_struct(type_annotations_typeArray,
 byte_i_ref, location_mesg, THREAD)) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("bad type_annotation_struct at %d", calc_num_annotations);
-("bad type_annotation_struct at %d", calc_num_annotations));
 // propagate failure back to caller
 return false;
 }
 }
 assert(num_annotations == calc_num_annotations, "sanity check");
 if (byte_i_ref != type_annotations_typeArray->length()) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)
-("read wrong amount of bytes at end of processing "
+("read wrong amount of bytes at end of processing type_annotations_typeArray (%d of %d bytes were read)",
-"type_annotations_typeArray (%d of %d bytes were read)",
+byte_i_ref, type_annotations_typeArray->length());
-byte_i_ref, type_annotations_typeArray->length()));
 return false;
 }
 return true;
 } // end rewrite_cp_refs_in_type_annotations_typeArray()
 AnnotationArray* type_annotations_typeArray, int &byte_i_ref,
 const char * location_mesg, TRAPS) {
 if ((byte_i_ref + 1) > type_annotations_typeArray->length()) {
 // not enough room for a target_type let alone the rest of a type_annotation
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a target_type");
-("length() is too small for a target_type"));
 return false;
 }
 u1 target_type = type_annotations_typeArray->at(byte_i_ref);
 byte_i_ref += 1;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("target_type=0x%.2x", target_type));
+log_debug(redefine, class, annotation)("target_type=0x%.2x", target_type);
-RC_TRACE_WITH_THREAD(0x02000000, THREAD, ("location=%s", location_mesg));
+log_debug(redefine, class, annotation)("location=%s", location_mesg);
 // Skip over target_info
 switch (target_type) {
 case 0x00:
 // kind: type parameter declaration of generic class or interface
 // type_parameter_target {
 //   u1 type_parameter_index;
 // }
 //
 if ((byte_i_ref + 1) > type_annotations_typeArray->length()) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a type_parameter_target");
-("length() is too small for a type_parameter_target"));
 return false;
 }
 u1 type_parameter_index = type_annotations_typeArray->at(byte_i_ref);
 byte_i_ref += 1;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("type_parameter_target: type_parameter_index=%d", type_parameter_index);
-("type_parameter_target: type_parameter_index=%d",
-type_parameter_index));
 } break;
 case 0x10:
 // kind: type in extends clause of class or interface declaration
 //       (including the direct superclass of an anonymous class declaration),
 // supertype_target {
 //   u2 supertype_index;
 // }
 //
 if ((byte_i_ref + 2) > type_annotations_typeArray->length()) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a supertype_target");
-("length() is too small for a supertype_target"));
 return false;
 }
 u2 supertype_index = Bytes::get_Java_u2((address)
 type_annotations_typeArray->adr_at(byte_i_ref));
 byte_i_ref += 2;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("supertype_target: supertype_index=%d", supertype_index);
-("supertype_target: supertype_index=%d", supertype_index));
 } break;
 case 0x11:
 // kind: type in bound of type parameter declaration of generic class or interface
 // location: ClassFile
 //   u1 type_parameter_index;
 //   u1 bound_index;
 // }
 //
 if ((byte_i_ref + 2) > type_annotations_typeArray->length()) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a type_parameter_bound_target");
-("length() is too small for a type_parameter_bound_target"));
 return false;
 }
 u1 type_parameter_index = type_annotations_typeArray->at(byte_i_ref);
 byte_i_ref += 1;
 u1 bound_index = type_annotations_typeArray->at(byte_i_ref);
 byte_i_ref += 1;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)
-("type_parameter_bound_target: type_parameter_index=%d, bound_index=%d",
+("type_parameter_bound_target: type_parameter_index=%d, bound_index=%d", type_parameter_index, bound_index);
-type_parameter_index, bound_index));
 } break;
 case 0x13:
 // kind: type in field declaration
 // location: field_info
 {
 // struct:
 // empty_target {
 // }
 //
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("empty_target");
-("empty_target"));
 } break;
 case 0x16:
 // kind: type in formal parameter declaration of method, constructor, or lambda expression
 // location: method_info
 // formal_parameter_target {
 //   u1 formal_parameter_index;
 // }
 //
 if ((byte_i_ref + 1) > type_annotations_typeArray->length()) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a formal_parameter_target");
-("length() is too small for a formal_parameter_target"));
 return false;
 }
 u1 formal_parameter_index = type_annotations_typeArray->at(byte_i_ref);
 byte_i_ref += 1;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)
-("formal_parameter_target: formal_parameter_index=%d",
+("formal_parameter_target: formal_parameter_index=%d", formal_parameter_index);
-formal_parameter_index));
 } break;
 case 0x17:
 // kind: type in throws clause of method or constructor
 // location: method_info
 // throws_target {
 //   u2 throws_type_index
 // }
 //
 if ((byte_i_ref + 2) > type_annotations_typeArray->length()) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a throws_target");
-("length() is too small for a throws_target"));
 return false;
 }
 u2 throws_type_index = Bytes::get_Java_u2((address)
 type_annotations_typeArray->adr_at(byte_i_ref));
 byte_i_ref += 2;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("throws_target: throws_type_index=%d", throws_type_index);
-("throws_target: throws_type_index=%d", throws_type_index));
 } break;
 case 0x40:
 // kind: type in local variable declaration
 // location: Code
 //   } table[table_length];
 // }
 //
 if ((byte_i_ref + 2) > type_annotations_typeArray->length()) {
 // not enough room for a table_length let alone the rest of a localvar_target
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a localvar_target table_length");
-("length() is too small for a localvar_target table_length"));
 return false;
 }
 u2 table_length = Bytes::get_Java_u2((address)
 type_annotations_typeArray->adr_at(byte_i_ref));
 byte_i_ref += 2;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("localvar_target: table_length=%d", table_length);
-("localvar_target: table_length=%d", table_length));
 int table_struct_size = 2 + 2 + 2; // 3 u2 variables per table entry
 int table_size = table_length * table_struct_size;
 if ((byte_i_ref + table_size) > type_annotations_typeArray->length()) {
 // not enough room for a table
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a table array of length %d", table_length);
-("length() is too small for a table array of length %d", table_length));
 return false;
 }
 // Skip over table
 byte_i_ref += table_size;
 // catch_target {
 //   u2 exception_table_index;
 // }
 //
 if ((byte_i_ref + 2) > type_annotations_typeArray->length()) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a catch_target");
-("length() is too small for a catch_target"));
 return false;
 }
 u2 exception_table_index = Bytes::get_Java_u2((address)
 type_annotations_typeArray->adr_at(byte_i_ref));
 byte_i_ref += 2;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("catch_target: exception_table_index=%d", exception_table_index);
-("catch_target: exception_table_index=%d", exception_table_index));
 } break;
 case 0x43:
 // kind: type in instanceof expression
 // location: Code
 // offset_target {
 //   u2 offset;
 // }
 //
 if ((byte_i_ref + 2) > type_annotations_typeArray->length()) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a offset_target");
-("length() is too small for a offset_target"));
 return false;
 }
 u2 offset = Bytes::get_Java_u2((address)
 type_annotations_typeArray->adr_at(byte_i_ref));
 byte_i_ref += 2;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("offset_target: offset=%d", offset);
-("offset_target: offset=%d", offset));
 } break;
 case 0x47:
 // kind: type in cast expression
 // location: Code
 //   u2 offset;
 //   u1 type_argument_index;
 // }
 //
 if ((byte_i_ref + 3) > type_annotations_typeArray->length()) {
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a type_argument_target");
-("length() is too small for a type_argument_target"));
 return false;
 }
 u2 offset = Bytes::get_Java_u2((address)
 type_annotations_typeArray->adr_at(byte_i_ref));
 byte_i_ref += 2;
 u1 type_argument_index = type_annotations_typeArray->at(byte_i_ref);
 byte_i_ref += 1;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)
-("type_argument_target: offset=%d, type_argument_index=%d",
+("type_argument_target: offset=%d, type_argument_index=%d", offset, type_argument_index);
-offset, type_argument_index));
 } break;
 default:
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("unknown target_type");
-("unknown target_type"));
 #ifdef ASSERT
 ShouldNotReachHere();
 #endif
 return false;
 }
 bool VM_RedefineClasses::skip_type_annotation_type_path(
 AnnotationArray* type_annotations_typeArray, int &byte_i_ref, TRAPS) {
 if ((byte_i_ref + 1) > type_annotations_typeArray->length()) {
 // not enough room for a path_length let alone the rest of the type_path
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("length() is too small for a type_path");
-("length() is too small for a type_path"));
 return false;
 }
 u1 path_length = type_annotations_typeArray->at(byte_i_ref);
 byte_i_ref += 1;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("type_path: path_length=%d", path_length);
-("type_path: path_length=%d", path_length));
 int calc_path_length = 0;
 for (; calc_path_length < path_length; calc_path_length++) {
 if ((byte_i_ref + 1 + 1) > type_annotations_typeArray->length()) {
 // not enough room for a path
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)
-("length() is too small for path entry %d of %d",
+("length() is too small for path entry %d of %d", calc_path_length, path_length);
-calc_path_length, path_length));
 return false;
 }
 u1 type_path_kind = type_annotations_typeArray->at(byte_i_ref);
 byte_i_ref += 1;
 u1 type_argument_index = type_annotations_typeArray->at(byte_i_ref);
 byte_i_ref += 1;
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)
 ("type_path: path[%d]: type_path_kind=%d, type_argument_index=%d",
-calc_path_length, type_path_kind, type_argument_index));
+calc_path_length, type_path_kind, type_argument_index);
 if (type_path_kind > 3 || (type_path_kind != 3 && type_argument_index != 0)) {
 // not enough room for a path
-RC_TRACE_WITH_THREAD(0x02000000, THREAD,
+log_debug(redefine, class, annotation)("inconsistent type_path values");
-("inconsistent type_path values"));
 return false;
 }
 }
 assert(path_length == calc_path_length, "sanity check");
 assert(stackmap_p + 2 <= stackmap_end, "no room for number_of_entries");
 u2 number_of_entries = Bytes::get_Java_u2(stackmap_p);
 stackmap_p += 2;
-RC_TRACE_WITH_THREAD(0x04000000, THREAD,
+log_debug(redefine, class, stackmap)("number_of_entries=%u", number_of_entries);
-("number_of_entries=%u", number_of_entries));
 // walk through each stack_map_frame
 u2 calc_number_of_entries = 0;
 for (; calc_number_of_entries < number_of_entries; calc_number_of_entries++) {
 // The stack_map_frame structure is a u1 frame_type followed by
 {
 assert(stackmap_p_ref + 2 <= stackmap_end, "no room for cpool_index");
 u2 cpool_index = Bytes::get_Java_u2(stackmap_p_ref);
 u2 new_cp_index = find_new_index(cpool_index);
 if (new_cp_index != 0) {
-RC_TRACE_WITH_THREAD(0x04000000, THREAD,
+log_debug(redefine, class, stackmap)("mapped old cpool_index=%d", cpool_index);
-("mapped old cpool_index=%d", cpool_index));
 Bytes::put_Java_u2(stackmap_p_ref, new_cp_index);
 cpool_index = new_cp_index;
 }
 stackmap_p_ref += 2;
-RC_TRACE_WITH_THREAD(0x04000000, THREAD,
+log_debug(redefine, class, stackmap)
-("frame_i=%u, frame_type=%u, cpool_index=%d", frame_i,
+("frame_i=%u, frame_type=%u, cpool_index=%d", frame_i, frame_type, cpool_index);
-frame_type, cpool_index));
 } break;
 // Uninitialized_variable_info {
 //   u1 tag = ITEM_Uninitialized; /* 8 */
 //   u2 offset;
 assert(stackmap_p_ref + 2 <= stackmap_end, "no room for offset");
 stackmap_p_ref += 2;
 break;
 default:
-RC_TRACE_WITH_THREAD(0x04000000, THREAD,
+log_debug(redefine, class, stackmap)("frame_i=%u, frame_type=%u, bad tag=0x%x", frame_i, frame_type, tag);
-("frame_i=%u, frame_type=%u, bad tag=0x%x", frame_i, frame_type, tag));
 ShouldNotReachHere();
 break;
 } // end switch (tag)
 } // end rewrite_cp_refs_in_verification_type_info()
 // update each field in klass to use new constant pool indices as needed
 for (JavaFieldStream fs(scratch_class); !fs.done(); fs.next()) {
 jshort cur_index = fs.name_index();
 jshort new_index = find_new_index(cur_index);
 if (new_index != 0) {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)("field-name_index change: %d to %d", cur_index, new_index);
-("field-name_index change: %d to %d", cur_index, new_index));
 fs.set_name_index(new_index);
 }
 cur_index = fs.signature_index();
 new_index = find_new_index(cur_index);
 if (new_index != 0) {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)("field-signature_index change: %d to %d", cur_index, new_index);
-("field-signature_index change: %d to %d", cur_index, new_index));
 fs.set_signature_index(new_index);
 }
 cur_index = fs.initval_index();
 new_index = find_new_index(cur_index);
 if (new_index != 0) {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)("field-initval_index change: %d to %d", cur_index, new_index);
-("field-initval_index change: %d to %d", cur_index, new_index));
 fs.set_initval_index(new_index);
 }
 cur_index = fs.generic_signature_index();
 new_index = find_new_index(cur_index);
 if (new_index != 0) {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)("field-generic_signature change: %d to %d", cur_index, new_index);
-("field-generic_signature change: %d to %d", cur_index, new_index));
 fs.set_generic_signature_index(new_index);
 }
 } // end for each field
 // Update constant pool indices in the inner classes info to use
 if (cur_index == 0) {
 continue;  // JVM spec. allows null inner class refs so skip it
 }
 int new_index = find_new_index(cur_index);
 if (new_index != 0) {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)("inner_class_info change: %d to %d", cur_index, new_index);
-("inner_class_info change: %d to %d", cur_index, new_index));
 iter.set_inner_class_info_index(new_index);
 }
 cur_index = iter.outer_class_info_index();
 new_index = find_new_index(cur_index);
 if (new_index != 0) {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)("outer_class_info change: %d to %d", cur_index, new_index);
-("outer_class_info change: %d to %d", cur_index, new_index));
 iter.set_outer_class_info_index(new_index);
 }
 cur_index = iter.inner_name_index();
 new_index = find_new_index(cur_index);
 if (new_index != 0) {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)("inner_name change: %d to %d", cur_index, new_index);
-("inner_name change: %d to %d", cur_index, new_index));
 iter.set_inner_name_index(new_index);
 }
 } // end for each inner class
 // Attach each method in klass to the new constant pool and update
 methodHandle method(THREAD, methods->at(i));
 method->set_constants(scratch_cp());
 int new_index = find_new_index(method->name_index());
 if (new_index != 0) {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)
-("method-name_index change: %d to %d", method->name_index(),
+("method-name_index change: %d to %d", method->name_index(), new_index);
-new_index));
 method->set_name_index(new_index);
 }
 new_index = find_new_index(method->signature_index());
 if (new_index != 0) {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)
-("method-signature_index change: %d to %d",
+("method-signature_index change: %d to %d", method->signature_index(), new_index);
-method->signature_index(), new_index));
 method->set_signature_index(new_index);
 }
 new_index = find_new_index(method->generic_signature_index());
 if (new_index != 0) {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)
-("method-generic_signature_index change: %d to %d",
+("method-generic_signature_index change: %d to %d", method->generic_signature_index(), new_index);
-method->generic_signature_index(), new_index));
 method->set_generic_signature_index(new_index);
 }
 // Update constant pool indices in the method's checked exception
 // table to use new constant indices as needed.
 method->checked_exceptions_start();
 for (int j = 0; j < cext_length; j++) {
 int cur_index = cext_table[j].class_cp_index;
 int new_index = find_new_index(cur_index);
 if (new_index != 0) {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)("cext-class_cp_index change: %d to %d", cur_index, new_index);
-("cext-class_cp_index change: %d to %d", cur_index, new_index));
 cext_table[j].class_cp_index = (u2)new_index;
 }
 } // end for each checked exception table entry
 } // end if there are checked exception table entries
 for (int j = 0; j < ext_length; j ++) {
 int cur_index = ex_table.catch_type_index(j);
 int new_index = find_new_index(cur_index);
 if (new_index != 0) {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)("ext-klass_index change: %d to %d", cur_index, new_index);
-("ext-klass_index change: %d to %d", cur_index, new_index));
 ex_table.set_catch_type_index(j, new_index);
 }
 } // end for each exception table entry
 // Update constant pool indices in the method's local variable
 method->localvariable_table_start();
 for (int j = 0; j < lvt_length; j++) {
 int cur_index = lv_table[j].name_cp_index;
 int new_index = find_new_index(cur_index);
 if (new_index != 0) {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)("lvt-name_cp_index change: %d to %d", cur_index, new_index);
-("lvt-name_cp_index change: %d to %d", cur_index, new_index));
 lv_table[j].name_cp_index = (u2)new_index;
 }
 cur_index = lv_table[j].descriptor_cp_index;
 new_index = find_new_index(cur_index);
 if (new_index != 0) {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)("lvt-descriptor_cp_index change: %d to %d", cur_index, new_index);
-("lvt-descriptor_cp_index change: %d to %d", cur_index,
-new_index));
 lv_table[j].descriptor_cp_index = (u2)new_index;
 }
 cur_index = lv_table[j].signature_cp_index;
 new_index = find_new_index(cur_index);
 if (new_index != 0) {
-RC_TRACE_WITH_THREAD(0x00080000, THREAD,
+log_trace(redefine, class, constantpool)("lvt-signature_cp_index change: %d to %d", cur_index, new_index);
-("lvt-signature_cp_index change: %d to %d", cur_index, new_index));
 lv_table[j].signature_cp_index = (u2)new_index;
 }
 } // end for each local variable table entry
 } // end if there are local variable table entries
 // 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);
-// Very noisy: only enable this call if you are trying to determine
-// that a specific class gets found by this routine.
-// RC_TRACE macro has an embedded ResourceMark
-// RC_TRACE_WITH_THREAD(0x00100000, THREAD,
-//   ("adjust check: name=%s", k->external_name()));
-// trace_name_printed = true;
 // 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()) {
 k->vtable()->adjust_method_entries(the_class, &trace_name_printed);
 }
 // With tracing we try not to "yack" too much. The position of
 // this trace assumes there are fewer obsolete methods than
 // EMCP methods.
-RC_TRACE(0x00000100, ("mark %s(%s) as obsolete",
+if (log_is_enabled(Trace, redefine, class, obsolete, mark)) {
-old_method->name()->as_C_string(),
+ResourceMark rm;
-old_method->signature()->as_C_string()));
+log_trace(redefine, class, obsolete, mark)
+("mark %s(%s) as obsolete", old_method->name()->as_C_string(), old_method->signature()->as_C_string());
+}
 }
 old_method->set_is_old();
 }
 for (int i = 0; i < _deleted_methods_length; ++i) {
 Method* old_method = _deleted_methods[i];
 old_method->set_is_obsolete();
 ++obsolete_count;
 // With tracing we try not to "yack" too much. The position of
 // this trace assumes there are fewer obsolete methods than
 // EMCP methods.
-RC_TRACE(0x00000100, ("mark deleted %s(%s) as obsolete",
+if (log_is_enabled(Trace, redefine, class, obsolete, mark)) {
-old_method->name()->as_C_string(),
+ResourceMark rm;
-old_method->signature()->as_C_string()));
+log_trace(redefine, class, obsolete, mark)
+("mark deleted %s(%s) as obsolete", old_method->name()->as_C_string(), old_method->signature()->as_C_string());
+}
 }
 assert((emcp_method_count + obsolete_count) == _old_methods->length(),
 "sanity check");
-RC_TRACE(0x00000100, ("EMCP_cnt=%d, obsolete_cnt=%d", emcp_method_count,
+log_trace(redefine, class, obsolete, mark)("EMCP_cnt=%d, obsolete_cnt=%d", emcp_method_count, obsolete_count);
-obsolete_count));
 return emcp_method_count;
 }
 // This internal class transfers the native function registration from old methods
 // to new methods.  It is designed to handle both the simple case of unchanged
 //      static global fields in the VM operation.
 void VM_RedefineClasses::redefine_single_class(jclass the_jclass,
 Klass* scratch_class_oop, TRAPS) {
 HandleMark hm(THREAD);   // make sure handles from this call are freed
-RC_TIMER_START(_timer_rsc_phase1);
+if (log_is_enabled(Info, redefine, class, timer)) {
+_timer_rsc_phase1.start();
+}
 instanceKlassHandle scratch_class(scratch_class_oop);
 oop the_class_mirror = JNIHandles::resolve_non_null(the_jclass);
 Klass* the_class_oop = java_lang_Class::as_Klass(the_class_mirror);
 the_class->set_has_been_redefined();
 // keep track of previous versions of this class
 the_class->add_previous_version(scratch_class, emcp_method_count);
-RC_TIMER_STOP(_timer_rsc_phase1);
+_timer_rsc_phase1.stop();
-RC_TIMER_START(_timer_rsc_phase2);
+if (log_is_enabled(Info, redefine, class, timer)) {
+_timer_rsc_phase2.start();
+}
 // Adjust constantpool caches and vtables for all classes
 // that reference methods of the evolved class.
 AdjustCpoolCacheAndVtable adjust_cpool_cache_and_vtable(THREAD);
 ClassLoaderDataGraph::classes_do(&adjust_cpool_cache_and_vtable);
 // 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 the classRedefinedCount field in the_class and in any
-// direct and indirect subclasses of the_class
-increment_class_counter((InstanceKlass *)the_class(), THREAD);
-// RC_TRACE macro has an embedded ResourceMark
-RC_TRACE_WITH_THREAD(0x00000001, THREAD,
-("redefined name=%s, count=%d (avail_mem=" UINT64_FORMAT "K)",
-the_class->external_name(),
-java_lang_Class::classRedefinedCount(the_class_mirror),
-os::available_memory() >> 10));
 {
 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_mirror), os::available_memory() >> 10);
 Events::log_redefinition(THREAD, "redefined class name=%s, count=%d",
 the_class->external_name(),
 java_lang_Class::classRedefinedCount(the_class_mirror));
 }
-RC_TIMER_STOP(_timer_rsc_phase2);
+_timer_rsc_phase2.stop();
 } // end redefine_single_class()
 // Increment the classRedefinedCount field in the specific InstanceKlass
 // and in all direct and indirect subclasses.
 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()
-RC_TRACE_WITH_THREAD(0x00000008, THREAD,
+log_debug(redefine, class, subclass)("updated count in subclass=%s to %d", ik->external_name(), new_count);
-("updated count in subclass=%s to %d", ik->external_name(), new_count));
 }
 for (Klass *subk = ik->subklass(); subk != NULL;
 subk = subk->next_sibling()) {
 if (subk->is_instance_klass()) {
 // Both array and instance classes have vtables.
 // a vtable should never contain old or obsolete methods
 ResourceMark rm(_thread);
 if (k->vtable_length() > 0 &&
 !k->vtable()->check_no_old_or_obsolete_entries()) {
-if (RC_TRACE_ENABLED(0x00004000)) {
+if (log_is_enabled(Trace, redefine, class, obsolete, metadata)) {
-RC_TRACE_WITH_THREAD(0x00004000, _thread,
+log_trace(redefine, class, obsolete, metadata)
-("klassVtable::check_no_old_or_obsolete_entries failure"
+("klassVtable::check_no_old_or_obsolete_entries failure -- OLD or OBSOLETE method found -- class: %s",
-" -- OLD or OBSOLETE method found -- class: %s",
+k->signature_name());
-k->signature_name()));
 k->vtable()->dump_vtable();
 }
 no_old_methods = false;
 }
 InstanceKlass *ik = InstanceKlass::cast(k);
 // an itable should never contain old or obsolete methods
 if (ik->itable_length() > 0 &&
 !ik->itable()->check_no_old_or_obsolete_entries()) {
-if (RC_TRACE_ENABLED(0x00004000)) {
+if (log_is_enabled(Trace, redefine, class, obsolete, metadata)) {
-RC_TRACE_WITH_THREAD(0x00004000, _thread,
+log_trace(redefine, class, obsolete, metadata)
-("klassItable::check_no_old_or_obsolete_entries failure"
+("klassItable::check_no_old_or_obsolete_entries failure -- OLD or OBSOLETE method found -- class: %s",
-" -- OLD or OBSOLETE method found -- class: %s",
+ik->signature_name());
-ik->signature_name()));
 ik->itable()->dump_itable();
 }
 no_old_methods = false;
 }
 // the constant pool cache should never contain non-deleted old or obsolete methods
 if (ik->constants() != NULL &&
 ik->constants()->cache() != NULL &&
 !ik->constants()->cache()->check_no_old_or_obsolete_entries()) {
-if (RC_TRACE_ENABLED(0x00004000)) {
+if (log_is_enabled(Trace, redefine, class, obsolete, metadata)) {
-RC_TRACE_WITH_THREAD(0x00004000, _thread,
+log_trace(redefine, class, obsolete, metadata)
-("cp-cache::check_no_old_or_obsolete_entries failure"
+("cp-cache::check_no_old_or_obsolete_entries failure -- OLD or OBSOLETE method found -- class: %s",
-" -- OLD or OBSOLETE method found -- class: %s",
+ik->signature_name());
-ik->signature_name()));
 ik->constants()->cache()->dump_cache();
 }
 no_old_methods = false;
 }
 }
 // print and fail guarantee if old methods are found.
 if (!no_old_methods) {
-if (RC_TRACE_ENABLED(0x00004000)) {
+if (log_is_enabled(Trace, redefine, class, obsolete, metadata)) {
 dump_methods();
 } else {
-tty->print_cr("INFO: use the '-XX:TraceRedefineClasses=16384' option "
+log_trace(redefine, class)("Use the '-Xlog:redefine+class*:' option "
 "to see more info about the following guarantee() failure.");
 }
 guarantee(false, "OLD and/or OBSOLETE method(s) found");
 }
 }
 void VM_RedefineClasses::dump_methods() {
 int j;
-RC_TRACE(0x00004000, ("_old_methods --"));
+log_trace(redefine, class, dump)("_old_methods --");
 for (j = 0; j < _old_methods->length(); ++j) {
+LogStreamHandle(Trace, redefine, class, dump) log_stream;
 Method* m = _old_methods->at(j);
-RC_TRACE_NO_CR(0x00004000, ("%4d  (%5d)  ", j, m->vtable_index()));
+log_stream.print("%4d  (%5d)  ", j, m->vtable_index());
-m->access_flags().print_on(tty);
+m->access_flags().print_on(&log_stream);
-tty->print(" --  ");
+log_stream.print(" --  ");
-m->print_name(tty);
+m->print_name(&log_stream);
-tty->cr();
+log_stream.cr();
 }
-RC_TRACE(0x00004000, ("_new_methods --"));
+log_trace(redefine, class, dump)("_new_methods --");
 for (j = 0; j < _new_methods->length(); ++j) {
+LogStreamHandle(Trace, redefine, class, dump) log_stream;
 Method* m = _new_methods->at(j);
-RC_TRACE_NO_CR(0x00004000, ("%4d  (%5d)  ", j, m->vtable_index()));
+log_stream.print("%4d  (%5d)  ", j, m->vtable_index());
-m->access_flags().print_on(tty);
+m->access_flags().print_on(&log_stream);
-tty->print(" --  ");
+log_stream.print(" --  ");
-m->print_name(tty);
+m->print_name(&log_stream);
-tty->cr();
+log_stream.cr();
 }
-RC_TRACE(0x00004000, ("_matching_(old/new)_methods --"));
+log_trace(redefine, class, dump)("_matching_methods --");
 for (j = 0; j < _matching_methods_length; ++j) {
+LogStreamHandle(Trace, redefine, class, dump) log_stream;
 Method* m = _matching_old_methods[j];
-RC_TRACE_NO_CR(0x00004000, ("%4d  (%5d)  ", j, m->vtable_index()));
+log_stream.print("%4d  (%5d)  ", j, m->vtable_index());
-m->access_flags().print_on(tty);
+m->access_flags().print_on(&log_stream);
-tty->print(" --  ");
+log_stream.print(" --  ");
-m->print_name(tty);
+m->print_name();
-tty->cr();
+log_stream.cr();
 m = _matching_new_methods[j];
-RC_TRACE_NO_CR(0x00004000, ("      (%5d)  ", m->vtable_index()));
+log_stream.print("      (%5d)  ", m->vtable_index());
-m->access_flags().print_on(tty);
+m->access_flags().print_on(&log_stream);
-tty->cr();
+log_stream.cr();
 }
-RC_TRACE(0x00004000, ("_deleted_methods --"));
+log_trace(redefine, class, dump)("_deleted_methods --");
 for (j = 0; j < _deleted_methods_length; ++j) {
+LogStreamHandle(Trace, redefine, class, dump) log_stream;
 Method* m = _deleted_methods[j];
-RC_TRACE_NO_CR(0x00004000, ("%4d  (%5d)  ", j, m->vtable_index()));
+log_stream.print("%4d  (%5d)  ", j, m->vtable_index());
-m->access_flags().print_on(tty);
+m->access_flags().print_on(&log_stream);
-tty->print(" --  ");
+log_stream.print(" --  ");
-m->print_name(tty);
+m->print_name(&log_stream);
-tty->cr();
+log_stream.cr();
 }
-RC_TRACE(0x00004000, ("_added_methods --"));
+log_trace(redefine, class, dump)("_added_methods --");
 for (j = 0; j < _added_methods_length; ++j) {
+LogStreamHandle(Trace, redefine, class, dump) log_stream;
 Method* m = _added_methods[j];
-RC_TRACE_NO_CR(0x00004000, ("%4d  (%5d)  ", j, m->vtable_index()));
+log_stream.print("%4d  (%5d)  ", j, m->vtable_index());
-m->access_flags().print_on(tty);
+m->access_flags().print_on(&log_stream);
-tty->print(" --  ");
+log_stream.print(" --  ");
-m->print_name(tty);
+m->print_name(&log_stream);
-tty->cr();
+log_stream.cr();
 }
 }
 void VM_RedefineClasses::print_on_error(outputStream* st) const {
 VM_Operation::print_on_error(st);

changeset 38259	b495d1cfe673
parent 38051	d092550d625d
child 38309	9b8e9c373740