jdk-sandbox: comparison hotspot/src/share/vm/code/nmethod.cpp

equal deleted inserted replaced

-:6767b0c66883
+:24b55ad4c228
 {
 {
 debug_only(No_Safepoint_Verifier nsv;)
 assert_locked_or_safepoint(CodeCache_lock);
-NOT_PRODUCT(_has_debug_info = false; )
+NOT_PRODUCT(_has_debug_info = false);
+_oops_do_mark_link       = NULL;
 _method                  = method;
 _entry_bci               = InvocationEntryBci;
-_link                    = 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;
 _lock_count = 0;
 _stack_traversal_mark    = 0;
 code_buffer->copy_oops_to(this);
-debug_only(check_store();)
+debug_only(verify_scavenge_root_oops());
 CodeCache::commit(this);
 VTune::create_nmethod(this);
 }
 if (PrintNativeNMethods || PrintDebugInfo || PrintRelocations || PrintDependencies) {
 {
 {
 debug_only(No_Safepoint_Verifier nsv;)
 assert_locked_or_safepoint(CodeCache_lock);
-NOT_PRODUCT(_has_debug_info = false; )
+NOT_PRODUCT(_has_debug_info = false);
+_oops_do_mark_link       = NULL;
 _method                  = method;
 _entry_bci               = InvocationEntryBci;
-_link                    = 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;
 _lock_count = 0;
 _stack_traversal_mark    = 0;
 code_buffer->copy_oops_to(this);
-debug_only(check_store();)
+debug_only(verify_scavenge_root_oops());
 CodeCache::commit(this);
 VTune::create_nmethod(this);
 }
 if (PrintNMethods || PrintDebugInfo || PrintRelocations || PrintDependencies) {
 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; )
+NOT_PRODUCT(_has_debug_info = false);
+_oops_do_mark_link       = NULL;
 _method                  = method;
 _compile_id              = compile_id;
 _comp_level              = comp_level;
 _entry_bci               = entry_bci;
-_link                    = NULL;
+_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
 // Copy contents of ScopeDescRecorder to nmethod
 code_buffer->copy_oops_to(this);
 debug_info->copy_to(this);
 dependencies->copy_to(this);
-debug_only(check_store();)
+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);
 // Print out more verbose output usually for a newly created nmethod.
 void nmethod::print_on(outputStream* st, const char* title) const {
 if (st != NULL) {
 ttyLocker ttyl;
 // Print a little tag line that looks like +PrintCompilation output:
-st->print("%3d%c  %s",
+int tlen = (int) strlen(title);
+bool do_nl = false;
+if (tlen > 0 && title[tlen-1] == '\n') { tlen--; do_nl = true; }
+st->print("%3d%c  %.*s",
 compile_id(),
 is_osr_method() ? '%' :
 method() != NULL &&
 is_native_method() ? 'n' : ' ',
-title);
+tlen, title);
 #ifdef TIERED
 st->print(" (%d) ", comp_level());
 #endif // TIERED
 if (WizardMode) st->print(" (" INTPTR_FORMAT ")", this);
-if (method() != NULL) {
+if (Universe::heap()->is_gc_active() && method() != NULL) {
-method()->print_short_name(st);
+st->print("(method)");
+} else if (method() != NULL) {
+method()->print_short_name(st);
 if (is_osr_method())
 st->print(" @ %d", osr_entry_bci());
 if (method()->code_size() > 0)
 st->print(" (%d bytes)", method()->code_size());
 }
+if (do_nl)  st->cr();
 }
 }
 void nmethod::print_nmethod(bool printmethod) {
 }
 }
 }
 }
+// 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_stack_traversal_mark(NMethodSweeper::traversal_count());
 }
 if (TraceClassUnloading && WizardMode) {
 tty->print_cr("[Class unloading: Making nmethod " INTPTR_FORMAT
 " unloadable], methodOop(" INTPTR_FORMAT
 "), cause(" INTPTR_FORMAT ")",
 this, (address)_method, (address)cause);
-cause->klass()->print();
+if (!Universe::heap()->is_gc_active())
+cause->klass()->print();
 }
 // If _method is already NULL the methodOop is about to be unloaded,
 // so we don't have to break the cycle. Note that it is possible to
 // have the methodOop live here, in case we unload the nmethod because
 // it is pointing to some oop (other than the methodOop) being unloaded.
 flags.state = unloaded;
 // The methodOop is gone at this point
 assert(_method == NULL, "Tautology");
-set_link(NULL);
+set_osr_link(NULL);
+//set_scavenge_root_link(NULL); // done by prune_scavenge_root_nmethods
 NMethodSweeper::notify(this);
 }
 void nmethod::invalidate_osr_method() {
 assert(_entry_bci != InvocationEntryBci, "wrong kind of nmethod");
 set_exception_cache(NULL);
 while(ec != NULL) {
 ExceptionCache* next = ec->next();
 delete ec;
 ec = next;
+}
+if (on_scavenge_root_list()) {
+CodeCache::drop_scavenge_root_nmethod(this);
 }
 ((CodeBlob*)(this))->flush();
 CodeCache::free(this);
 // The oop should be kept alive
 keep_alive->do_oop(root);
 return false;
 }
 }
-assert(unloading_occurred, "Inconsistency in unloading");
+// If ScavengeRootsInCode is true, an nmethod might be unloaded
+// simply because one of its constant oops has gone dead.
+// No actual classes need to be unloaded in order for this to occur.
+assert(unloading_occurred || ScavengeRootsInCode, "Inconsistency in unloading");
 make_unloaded(is_alive, obj);
 return true;
 }
 // ------------------------------------------------------------------
 }
 }
 }
 // Scopes
+// This includes oop constants not inlined in the code stream.
 for (oop* p = oops_begin(); p < oops_end(); p++) {
 if (*p == Universe::non_oop_word())  continue;  // skip non-oops
 f->do_oop(p);
 }
+}
+#define NMETHOD_SENTINEL ((nmethod*)badAddress)
+nmethod* volatile nmethod::_oops_do_mark_nmethods;
+// An nmethod is "marked" if its _mark_link is set non-null.
+// Even if it is the end of the linked list, it will have a non-null link value,
+// as long as it is on the list.
+// This code must be MP safe, because it is used from parallel GC passes.
+bool nmethod::test_set_oops_do_mark() {
+assert(nmethod::oops_do_marking_is_active(), "oops_do_marking_prologue must be called");
+nmethod* observed_mark_link = _oops_do_mark_link;
+if (observed_mark_link == NULL) {
+// Claim this nmethod for this thread to mark.
+observed_mark_link = (nmethod*)
+Atomic::cmpxchg_ptr(NMETHOD_SENTINEL, &_oops_do_mark_link, NULL);
+if (observed_mark_link == NULL) {
+// Atomically append this nmethod (now claimed) to the head of the list:
+nmethod* observed_mark_nmethods = _oops_do_mark_nmethods;
+for (;;) {
+nmethod* required_mark_nmethods = observed_mark_nmethods;
+_oops_do_mark_link = required_mark_nmethods;
+observed_mark_nmethods = (nmethod*)
+Atomic::cmpxchg_ptr(this, &_oops_do_mark_nmethods, required_mark_nmethods);
+if (observed_mark_nmethods == required_mark_nmethods)
+break;
+}
+// Mark was clear when we first saw this guy.
+NOT_PRODUCT(if (TraceScavenge)  print_on(tty, "oops_do, mark\n"));
+return false;
+}
+}
+// On fall through, another racing thread marked this nmethod before we did.
+return true;
+}
+void nmethod::oops_do_marking_prologue() {
+NOT_PRODUCT(if (TraceScavenge)  tty->print_cr("[oops_do_marking_prologue"));
+assert(_oops_do_mark_nmethods == NULL, "must not call oops_do_marking_prologue twice in a row");
+// We use cmpxchg_ptr instead of regular assignment here because the user
+// may fork a bunch of threads, and we need them all to see the same state.
+void* observed = Atomic::cmpxchg_ptr(NMETHOD_SENTINEL, &_oops_do_mark_nmethods, NULL);
+guarantee(observed == NULL, "no races in this sequential code");
+}
+void nmethod::oops_do_marking_epilogue() {
+assert(_oops_do_mark_nmethods != NULL, "must not call oops_do_marking_epilogue twice in a row");
+nmethod* cur = _oops_do_mark_nmethods;
+while (cur != NMETHOD_SENTINEL) {
+assert(cur != NULL, "not NULL-terminated");
+nmethod* next = cur->_oops_do_mark_link;
+cur->_oops_do_mark_link = NULL;
+NOT_PRODUCT(if (TraceScavenge)  cur->print_on(tty, "oops_do, unmark\n"));
+cur = next;
+}
+void* required = _oops_do_mark_nmethods;
+void* observed = Atomic::cmpxchg_ptr(NULL, &_oops_do_mark_nmethods, required);
+guarantee(observed == required, "no races in this sequential code");
+NOT_PRODUCT(if (TraceScavenge)  tty->print_cr("oops_do_marking_epilogue]"));
+}
+class DetectScavengeRoot: public OopClosure {
+bool     _detected_scavenge_root;
+public:
+DetectScavengeRoot() : _detected_scavenge_root(false)
+{ NOT_PRODUCT(_print_nm = NULL); }
+bool detected_scavenge_root() { return _detected_scavenge_root; }
+virtual void do_oop(oop* p) {
+if ((*p) != NULL && (*p)->is_scavengable()) {
+NOT_PRODUCT(maybe_print(p));
+_detected_scavenge_root = true;
+}
+}
+virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); }
+#ifndef PRODUCT
+nmethod* _print_nm;
+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 non-perm oop "PTR_FORMAT" (found at "PTR_FORMAT")",
+_print_nm, (int)((intptr_t)p - (intptr_t)_print_nm),
+(intptr_t)(*p), (intptr_t)p);
+(*p)->print();
+}
+#endif //PRODUCT
+};
+bool nmethod::detect_scavenge_root_oops() {
+DetectScavengeRoot detect_scavenge_root;
+NOT_PRODUCT(if (TraceScavenge)  detect_scavenge_root._print_nm = this);
+oops_do(&detect_scavenge_root);
+return detect_scavenge_root.detected_scavenge_root();
 }
 // Method that knows how to preserve outgoing arguments at call. This method must be
 // called with a frame corresponding to a Java invoke
 void nmethod::preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map, OopClosure* f) {
 // -----------------------------------------------------------------------------
 // Verification
+class VerifyOopsClosure: public OopClosure {
+nmethod* _nm;
+bool     _ok;
+public:
+VerifyOopsClosure(nmethod* nm) : _nm(nm), _ok(true) { }
+bool ok() { return _ok; }
+virtual void do_oop(oop* p) {
+if ((*p) == NULL || (*p)->is_oop())  return;
+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));
+}
+virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); }
+};
 void nmethod::verify() {
 // Hmm. OSR methods can be deopted but not marked as zombie or not_entrant
 // seems odd.
 for (PcDesc* p = scopes_pcs_begin(); p < scopes_pcs_end(); p++) {
 if (! p->verify(this)) {
 tty->print_cr("\t\tin nmethod at " INTPTR_FORMAT " (pcs)", this);
 }
 }
+VerifyOopsClosure voc(this);
+oops_do(&voc);
+assert(voc.ok(), "embedded oops must be OK");
+verify_scavenge_root_oops();
 verify_scopes();
 }
 // -----------------------------------------------------------------------------
 // Non-product code
 #ifndef PRODUCT
-void nmethod::check_store() {
+class DebugScavengeRoot: public OopClosure {
-// Make sure all oops in the compiled code are tenured
+nmethod* _nm;
+bool     _ok;
-RelocIterator iter(this);
+public:
-while (iter.next()) {
+DebugScavengeRoot(nmethod* nm) : _nm(nm), _ok(true) { }
-if (iter.type() == relocInfo::oop_type) {
+bool ok() { return _ok; }
-oop_Relocation* reloc = iter.oop_reloc();
+virtual void do_oop(oop* p) {
-oop obj = reloc->oop_value();
+if ((*p) == NULL || !(*p)->is_scavengable())  return;
-if (obj != NULL && !obj->is_perm()) {
+if (_ok) {
-fatal("must be permanent oop in compiled code");
+_nm->print_nmethod(true);
-}
+_ok = false;
 }
-}
+tty->print_cr("*** non-perm oop "PTR_FORMAT" found at "PTR_FORMAT" (offset %d)",
+(intptr_t)(*p), (intptr_t)p, (int)((intptr_t)p - (intptr_t)_nm));
+(*p)->print();
+}
+virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); }
+};
+void nmethod::verify_scavenge_root_oops() {
+if (!on_scavenge_root_list()) {
+// Actually look inside, to verify the claim that it's clean.
+DebugScavengeRoot debug_scavenge_root(this);
+oops_do(&debug_scavenge_root);
+if (!debug_scavenge_root.ok())
+fatal("found an unadvertised bad non-perm oop in the code cache");
+}
+assert(scavenge_root_not_marked(), "");
 }
 #endif // PRODUCT
 // Printing operations
 if (level())          tty->print("l%d ", level());
 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 ");
 tty->print_cr("}:");
 }
 if (size              () > 0) tty->print_cr(" total in heap  [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d",
 (address)this,
 (address)this + size(),

changeset 3908	24b55ad4c228
parent 3686	69c1b5228547
child 3912	3aaaaad1ccb0