jdk8-mips64-public/hotspot: comparison src/share/vm/code/nmethod.cpp

-:a693e51ac197
+:2a47bd84841f
 //-------------end of code for ExceptionCache--------------
-void nmFlags::clear() {
-assert(sizeof(nmFlags) == sizeof(int), "using more than one word for nmFlags");
-*(jint*)this = 0;
-}
 int nmethod::total_size() const {
 return
 code_size()          +
 stub_size()          +
 consts_size()        +
 if (is_osr_method())     return "osr";
 if (method() != NULL && is_native_method())  return "c2n";
 return NULL;
 }
-// %%% This variable is no longer used?
+// Fill in default values for various flag fields
-int nmethod::_zombie_instruction_size = NativeJump::instruction_size;
+void nmethod::init_defaults() {
+_state                      = alive;
+_marked_for_reclamation     = 0;
+_has_flushed_dependencies   = 0;
+_speculatively_disconnected = 0;
+_has_unsafe_access          = 0;
+_has_method_handle_invokes  = 0;
+_marked_for_deoptimization  = 0;
+_lock_count                 = 0;
+_stack_traversal_mark       = 0;
+_unload_reported            = false;           // jvmti state
+NOT_PRODUCT(_has_debug_info = false);
+_oops_do_mark_link       = NULL;
+_jmethod_id              = NULL;
+_osr_link                = NULL;
+_scavenge_root_link      = NULL;
+_scavenge_root_state     = 0;
+_saved_nmethod_link      = NULL;
+_compiler                = NULL;
+#ifdef HAVE_DTRACE_H
+_trap_offset             = 0;
+#endif // def HAVE_DTRACE_H
+}
 nmethod* nmethod::new_native_nmethod(methodHandle method,
 CodeBuffer *code_buffer,
 int vep_offset,
 {
 {
 debug_only(No_Safepoint_Verifier nsv;)
 assert_locked_or_safepoint(CodeCache_lock);
-NOT_PRODUCT(_has_debug_info = false);
+init_defaults();
-_oops_do_mark_link       = NULL;
 _method                  = method;
 _entry_bci               = InvocationEntryBci;
-_jmethod_id              = NULL;
-_osr_link                = NULL;
-_scavenge_root_link      = NULL;
-_scavenge_root_state     = 0;
-_saved_nmethod_link      = NULL;
-_compiler                = NULL;
 // We have no exception handler or deopt handler make the
 // values something that will never match a pc like the nmethod vtable entry
 _exception_offset        = 0;
 _deoptimize_offset       = 0;
 _deoptimize_mh_offset    = 0;
 _orig_pc_offset          = 0;
-#ifdef HAVE_DTRACE_H
-_trap_offset             = 0;
-#endif // def HAVE_DTRACE_H
 _stub_offset             = data_offset();
 _consts_offset           = data_offset();
 _oops_offset             = data_offset();
 _scopes_data_offset      = _oops_offset          + round_to(code_buffer->total_oop_size(), oopSize);
 _scopes_pcs_offset       = _scopes_data_offset;
 _verified_entry_point    = instructions_begin() + offsets->value(CodeOffsets::Verified_Entry);
 _osr_entry_point         = NULL;
 _exception_cache         = NULL;
 _pc_desc_cache.reset_to(NULL);
-flags.clear();
-flags.state              = alive;
-_markedForDeoptimization = 0;
-_lock_count = 0;
-_stack_traversal_mark    = 0;
 code_buffer->copy_oops_to(this);
 debug_only(verify_scavenge_root_oops());
 CodeCache::commit(this);
-VTune::create_nmethod(this);
 }
 if (PrintNativeNMethods || PrintDebugInfo || PrintRelocations || PrintDependencies) {
 ttyLocker ttyl;  // keep the following output all in one block
 // This output goes directly to the tty, not the compiler log.
 {
 {
 debug_only(No_Safepoint_Verifier nsv;)
 assert_locked_or_safepoint(CodeCache_lock);
-NOT_PRODUCT(_has_debug_info = false);
+init_defaults();
-_oops_do_mark_link       = NULL;
 _method                  = method;
 _entry_bci               = InvocationEntryBci;
-_jmethod_id              = NULL;
-_osr_link                = NULL;
-_scavenge_root_link      = NULL;
-_scavenge_root_state     = 0;
-_compiler                = NULL;
 // We have no exception handler or deopt handler make the
 // values something that will never match a pc like the nmethod vtable entry
 _exception_offset        = 0;
 _deoptimize_offset       = 0;
 _deoptimize_mh_offset    = 0;
 _verified_entry_point    = instructions_begin() + offsets->value(CodeOffsets::Verified_Entry);
 _osr_entry_point         = NULL;
 _exception_cache         = NULL;
 _pc_desc_cache.reset_to(NULL);
-flags.clear();
-flags.state              = alive;
-_markedForDeoptimization = 0;
-_lock_count = 0;
-_stack_traversal_mark    = 0;
 code_buffer->copy_oops_to(this);
 debug_only(verify_scavenge_root_oops());
 CodeCache::commit(this);
-VTune::create_nmethod(this);
 }
 if (PrintNMethods || PrintDebugInfo || PrintRelocations || PrintDependencies) {
 ttyLocker ttyl;  // keep the following output all in one block
 // This output goes directly to the tty, not the compiler log.
 assert(debug_info->oop_recorder() == code_buffer->oop_recorder(), "shared OR");
 {
 debug_only(No_Safepoint_Verifier nsv;)
 assert_locked_or_safepoint(CodeCache_lock);
-NOT_PRODUCT(_has_debug_info = false);
+init_defaults();
-_oops_do_mark_link       = NULL;
 _method                  = method;
-_jmethod_id              = NULL;
+_entry_bci               = entry_bci;
 _compile_id              = compile_id;
 _comp_level              = comp_level;
-_entry_bci               = entry_bci;
-_osr_link                = NULL;
-_scavenge_root_link      = NULL;
-_scavenge_root_state     = 0;
 _compiler                = compiler;
 _orig_pc_offset          = orig_pc_offset;
-#ifdef HAVE_DTRACE_H
-_trap_offset             = 0;
-#endif // def HAVE_DTRACE_H
 _stub_offset             = instructions_offset() + code_buffer->total_offset_of(code_buffer->stubs()->start());
 // Exception handler and deopt handler are in the stub section
 _exception_offset        = _stub_offset + offsets->value(CodeOffsets::Exceptions);
 _deoptimize_offset       = _stub_offset + offsets->value(CodeOffsets::Deopt);
 _verified_entry_point    = instructions_begin() + offsets->value(CodeOffsets::Verified_Entry);
 _osr_entry_point         = instructions_begin() + offsets->value(CodeOffsets::OSR_Entry);
 _exception_cache         = NULL;
 _pc_desc_cache.reset_to(scopes_pcs_begin());
-flags.clear();
-flags.state              = alive;
-_markedForDeoptimization = 0;
-_unload_reported         = false;           // jvmti state
-_lock_count = 0;
-_stack_traversal_mark    = 0;
 // Copy contents of ScopeDescRecorder to nmethod
 code_buffer->copy_oops_to(this);
 debug_info->copy_to(this);
 dependencies->copy_to(this);
 if (ScavengeRootsInCode && detect_scavenge_root_oops()) {
 CodeCache::add_scavenge_root_nmethod(this);
 }
 debug_only(verify_scavenge_root_oops());
 CodeCache::commit(this);
-VTune::create_nmethod(this);
 // Copy contents of ExceptionHandlerTable to nmethod
 handler_table->copy_to(this);
 nul_chk_table->copy_to(this);
 print_nul_chk_table();
 }
 if (xtty != NULL) {
 xtty->tail("print_nmethod");
 }
-}
-void nmethod::set_version(int v) {
-flags.version = v;
 }
 // Promote one word from an assembly-time handle to a live embedded oop.
 inline void nmethod::initialize_immediate_oop(oop* dest, jobject handle) {
 }
 // This is a private interface with the sweeper.
 void nmethod::mark_as_seen_on_stack() {
 assert(is_not_entrant(), "must be a non-entrant method");
+// Set the traversal mark to ensure that the sweeper does 2
+// cleaning passes before moving to zombie.
 set_stack_traversal_mark(NMethodSweeper::traversal_count());
 }
 // Tell if a non-entrant method can be converted to a zombie (i.e., there is no activations on the stack)
 bool nmethod::can_not_entrant_be_converted() {
 // Transitioning directly from live to unloaded -- so
 // we need to force a cache clean-up; remember this
 // for later on.
 CodeCache::set_needs_cache_clean(true);
 }
-flags.state = unloaded;
+_state = unloaded;
 // Log the unloading.
 log_state_change();
 // The methodOop is gone at this point
 void nmethod::log_state_change() const {
 if (LogCompilation) {
 if (xtty != NULL) {
 ttyLocker ttyl;  // keep the following output all in one block
-if (flags.state == unloaded) {
+if (_state == unloaded) {
 xtty->begin_elem("make_unloaded thread='" UINTX_FORMAT "'",
 os::current_thread_id());
 } else {
 xtty->begin_elem("make_not_entrant thread='" UINTX_FORMAT "'%s",
 os::current_thread_id(),
-(flags.state == zombie ? " zombie='1'" : ""));
+(_state == zombie ? " zombie='1'" : ""));
 }
 log_identity(xtty);
 xtty->stamp();
 xtty->end_elem();
 }
 }
-if (PrintCompilation && flags.state != unloaded) {
+if (PrintCompilation && _state != unloaded) {
-print_on(tty, flags.state == zombie ? "made zombie " : "made not entrant ");
+print_on(tty, _state == zombie ? "made zombie " : "made not entrant ");
 tty->cr();
 }
 }
 // Common functionality for both make_not_entrant and make_zombie
 bool nmethod::make_not_entrant_or_zombie(unsigned int state) {
 assert(state == zombie || state == not_entrant, "must be zombie or not_entrant");
 bool was_alive = false;
-// Make sure the nmethod is not flushed in case of a safepoint in code below.
+// Make sure neither the nmethod nor the method is flushed in case of a safepoint in code below.
 nmethodLocker nml(this);
+methodHandle the_method(method());
 {
 // If the method is already zombie there is nothing to do
 if (is_zombie()) {
 return false;
 }
 // Enter critical section.  Does not block for safepoint.
 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
-if (flags.state == state) {
+if (_state == state) {
 // another thread already performed this transition so nothing
 // to do, but return false to indicate this.
 return false;
 }
 // The caller can be calling the method statically or through an inline
 // cache call.
 if (!is_osr_method() && !is_not_entrant()) {
 NativeJump::patch_verified_entry(entry_point(), verified_entry_point(),
 SharedRuntime::get_handle_wrong_method_stub());
-assert (NativeJump::instruction_size == nmethod::_zombie_instruction_size, "");
+}
-}
+if (is_in_use()) {
-was_alive = is_in_use(); // Read state under lock
+// It's a true state change, so mark the method as decompiled.
+// Do it only for transition from alive.
+inc_decompile_count();
+}
 // Change state
-flags.state = state;
+_state = state;
 // Log the transition once
 log_state_change();
+// Remove nmethod from method.
+// We need to check if both the _code and _from_compiled_code_entry_point
+// refer to this nmethod because there is a race in setting these two fields
+// in methodOop as seen in bugid 4947125.
+// If the vep() points to the zombie nmethod, the memory for the nmethod
+// could be flushed and the compiler and vtable stubs could still call
+// through it.
+if (method() != NULL && (method()->code() == this ||
+method()->from_compiled_entry() == verified_entry_point())) {
+HandleMark hm;
+method()->clear_code();
+}
+if (state == not_entrant) {
+mark_as_seen_on_stack();
+}
 } // leave critical region under Patching_lock
 // When the nmethod becomes zombie it is no longer alive so the
 // dependencies must be flushed.  nmethods in the not_entrant
 // state will be flushed later when the transition to zombie
 // happens or they get unloaded.
 if (state == zombie) {
+// zombie only - if a JVMTI agent has enabled the CompiledMethodUnload event
+// and it hasn't already been reported for this nmethod then report it now.
+// (the event may have been reported earilier if the GC marked it for unloading).
+post_compiled_method_unload();
 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
 flush_dependencies(NULL);
 } else {
 assert(state == not_entrant, "other cases may need to be handled differently");
 }
-if (state == not_entrant) {
-Events::log("Make nmethod not entrant " INTPTR_FORMAT, this);
-} else {
-Events::log("Make nmethod zombie " INTPTR_FORMAT, this);
-}
 if (TraceCreateZombies) {
 tty->print_cr("nmethod <" INTPTR_FORMAT "> code made %s", this, (state == not_entrant) ? "not entrant" : "zombie");
 }
 // Make sweeper aware that there is a zombie method that needs to be removed
 NMethodSweeper::notify(this);
-// not_entrant only stuff
-if (state == not_entrant) {
-mark_as_seen_on_stack();
-}
-if (was_alive) {
-// It's a true state change, so mark the method as decompiled.
-// Do it only for transition from alive.
-inc_decompile_count();
-}
-// zombie only - if a JVMTI agent has enabled the CompiledMethodUnload event
-// and it hasn't already been reported for this nmethod then report it now.
-// (the event may have been reported earilier if the GC marked it for unloading).
-if (state == zombie) {
-post_compiled_method_unload();
-}
-// Zombie only stuff
-if (state == zombie) {
-VTune::delete_nmethod(this);
-}
-// Check whether method got unloaded at a safepoint before this,
-// if so we can skip the flushing steps below
-if (method() == NULL) return true;
-// Remove nmethod from method.
-// We need to check if both the _code and _from_compiled_code_entry_point
-// refer to this nmethod because there is a race in setting these two fields
-// in methodOop as seen in bugid 4947125.
-// If the vep() points to the zombie nmethod, the memory for the nmethod
-// could be flushed and the compiler and vtable stubs could still call
-// through it.
-if (method()->code() == this ||
-method()->from_compiled_entry() == verified_entry_point()) {
-HandleMark hm;
-method()->clear_code();
-}
 return true;
 }
 void nmethod::flush() {
 void nmethod_init() {
 // make sure you didn't forget to adjust the filler fields
-assert(sizeof(nmFlags) <= 4,           "nmFlags occupies more than a word");
 assert(sizeof(nmethod) % oopSize == 0, "nmethod size must be multiple of a word");
 }
 //-------------------------------------------------------------------------------------------
 tty->cr();
 if (WizardMode) {
 tty->print("((nmethod*) "INTPTR_FORMAT ") ", this);
 tty->print(" for method " INTPTR_FORMAT , (address)method());
 tty->print(" { ");
-if (version())        tty->print("v%d ", version());
 if (is_in_use())      tty->print("in_use ");
 if (is_not_entrant()) tty->print("not_entrant ");
 if (is_zombie())      tty->print("zombie ");
 if (is_unloaded())    tty->print("unloaded ");
 if (on_scavenge_root_list())  tty->print("scavenge_root ");

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/code/nmethod.cpp

src/share/vm/code/nmethod.cpp