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

-:3068270ba476
+:2b8e28fdf503
 /*
-* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 #define DTRACE_METHOD_UNLOAD_PROBE(method)
 #endif
 bool nmethod::is_compiled_by_c1() const {
-if (compiler() == NULL || method() == NULL)  return false;  // can happen during debug printing
+if (compiler() == NULL) {
-if (is_native_method()) return false;
+return false;
+}
 return compiler()->is_c1();
 }
 bool nmethod::is_compiled_by_c2() const {
-if (compiler() == NULL || method() == NULL)  return false;  // can happen during debug printing
+if (compiler() == NULL) {
-if (is_native_method()) return false;
+return false;
+}
 return compiler()->is_c2();
 }
 bool nmethod::is_compiled_by_shark() const {
-if (is_native_method()) return false;
+if (compiler() == NULL) {
-assert(compiler() != NULL, "must be");
+return false;
+}
 return compiler()->is_shark();
 }
 // Fill in default values for various flag fields
 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;
 _lazy_critical_native       = 0;
 _has_wide_vectors           = 0;
 _marked_for_deoptimization  = 0;
 _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
 _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);
 _osr_entry_point         = NULL;
 _exception_cache         = NULL;
 _pc_desc_cache.reset_to(NULL);
+_hotness_counter         = NMethodSweeper::hotness_counter_reset_val();
 code_buffer->copy_values_to(this);
 if (ScavengeRootsInCode && detect_scavenge_root_oops()) {
 CodeCache::add_scavenge_root_nmethod(this);
 Universe::heap()->register_nmethod(this);
 _entry_point             = code_begin()          + offsets->value(CodeOffsets::Entry);
 _verified_entry_point    = code_begin()          + offsets->value(CodeOffsets::Verified_Entry);
 _osr_entry_point         = NULL;
 _exception_cache         = NULL;
 _pc_desc_cache.reset_to(NULL);
+_hotness_counter         = NMethodSweeper::hotness_counter_reset_val();
 code_buffer->copy_values_to(this);
 debug_only(verify_scavenge_root_oops());
 CodeCache::commit(this);
 }
 }
 }
 }
 #endif // def HAVE_DTRACE_H
-void* nmethod::operator new(size_t size, int nmethod_size) {
+void* nmethod::operator new(size_t size, int nmethod_size) throw() {
 // Not critical, may return null if there is too little continuous memory
 return CodeCache::allocate(nmethod_size);
 }
 nmethod::nmethod(
 _entry_bci               = entry_bci;
 _compile_id              = compile_id;
 _comp_level              = comp_level;
 _compiler                = compiler;
 _orig_pc_offset          = orig_pc_offset;
+_hotness_counter         = NMethodSweeper::hotness_counter_reset_val();
 // Section offsets
 _consts_offset           = content_offset()      + code_buffer->total_offset_of(code_buffer->consts());
 _stub_offset             = content_offset()      + code_buffer->total_offset_of(code_buffer->stubs());
 }
 }
 // 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");
+assert(is_alive(), "Must be an alive 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());
 }
 // The Method* is gone at this point
 assert(_method == NULL, "Tautology");
 set_osr_link(NULL);
 //set_scavenge_root_link(NULL); // done by prune_scavenge_root_nmethods
-NMethodSweeper::notify(this);
+NMethodSweeper::notify();
 }
 void nmethod::invalidate_osr_method() {
 assert(_entry_bci != InvocationEntryBci, "wrong kind of nmethod");
 // Remove from list of active nmethods
 // This nmethod may have already been unloaded during a full GC.
 if ((state == zombie) && !is_unloaded()) {
 nmethod_needs_unregister = true;
 }
+// Must happen before state change. Otherwise we have a race condition in
+// nmethod::can_not_entrant_be_converted(). I.e., a method can immediately
+// transition its state from 'not_entrant' to 'zombie' without having to wait
+// for stack scanning.
+if (state == not_entrant) {
+mark_as_seen_on_stack();
+OrderAccess::storestore();
+}
 // Change state
 _state = state;
 // Log the transition once
 log_state_change();
 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
 #ifdef ASSERT
 // It's no longer safe to access the oops section since zombie
 // nmethods aren't scanned for GC.
 _oops_are_stale = true;
 #endif
+// the Method may be reclaimed by class unloading now that the
+// nmethod is in zombie state
+set_method(NULL);
 } else {
 assert(state == not_entrant, "other cases may need to be handled differently");
 }
 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);
+NMethodSweeper::notify();
 return true;
 }
 void nmethod::flush() {
 ec = next;
 }
 if (on_scavenge_root_list()) {
 CodeCache::drop_scavenge_root_nmethod(this);
-}
-if (is_speculatively_disconnected()) {
-CodeCache::remove_saved_code(this);
 }
 #ifdef SHARK
 ((SharkCompiler *) compiler())->free_compiled_method(insts_begin());
 #endif // SHARK
 void maybe_print(oop* p) {
 if (_print_nm == NULL)  return;
 if (!_detected_scavenge_root)  _print_nm->print_on(tty, "new scavenge root");
 tty->print_cr(""PTR_FORMAT"[offset=%d] detected scavengable oop "PTR_FORMAT" (found at "PTR_FORMAT")",
 _print_nm, (int)((intptr_t)p - (intptr_t)_print_nm),
-(intptr_t)(*p), (intptr_t)p);
+(void *)(*p), (intptr_t)p);
 (*p)->print();
 }
 #endif //PRODUCT
 };
 if (_ok) {
 _nm->print_nmethod(true);
 _ok = false;
 }
 tty->print_cr("*** non-oop "PTR_FORMAT" found at "PTR_FORMAT" (offset %d)",
-(intptr_t)(*p), (intptr_t)p, (int)((intptr_t)p - (intptr_t)_nm));
+(void *)(*p), (intptr_t)p, (int)((intptr_t)p - (intptr_t)_nm));
 }
 virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); }
 };
 void nmethod::verify() {
 if (_ok) {
 _nm->print_nmethod(true);
 _ok = false;
 }
 tty->print_cr("*** scavengable oop "PTR_FORMAT" found at "PTR_FORMAT" (offset %d)",
-(intptr_t)(*p), (intptr_t)p, (int)((intptr_t)p - (intptr_t)_nm));
+(void *)(*p), (intptr_t)p, (int)((intptr_t)p - (intptr_t)_nm));
 (*p)->print();
 }
 virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); }
 };

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

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

src/share/vm/code/nmethod.cpp