graal-compiler: src/share/vm/code/nmethod.cpp comparison

comparison src/share/vm/code/nmethod.cpp @ 12355:cefad50507d8

Merge with hs25-b53

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Fri, 11 Oct 2013 10:38:03 +0200
parents	d0aeaf72c7bd 268e7a2178d7
children	359f7e70ae7f

comparison

equal deleted inserted replaced

-:ccb4f2af2319
+:cefad50507d8
 /*
-* 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_graal() const {
 if (compiler() == NULL || method() == NULL)  return false;  // can happen during debug printing
 if (is_native_method()) return false;
 return compiler()->is_graal();
 }
 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 GRAAL
 _graal_installed_code   = NULL;
 _triggered_deoptimizations = NULL;
 #endif
 _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);
 }
 debug_only(verify_scavenge_root_oops());
 CodeCache::commit(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) throw () {
+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());
 code_buffer->copy_values_to(this);
 debug_info->copy_to(this);
 dependencies->copy_to(this);
 if (ScavengeRootsInCode && detect_scavenge_root_oops()) {
 CodeCache::add_scavenge_root_nmethod(this);
+Universe::heap()->register_nmethod(this);
 }
 debug_only(verify_scavenge_root_oops());
 CodeCache::commit(this);
 }
 }
 // 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
 // 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());
 No_Safepoint_Verifier nsv;
+// during patching, depending on the nmethod state we must notify the GC that
+// code has been unloaded, unregistering it. We cannot do this right while
+// holding the Patching_lock because we need to use the CodeCache_lock. This
+// would be prone to deadlocks.
+// This flag is used to remember whether we need to later lock and unregister.
+bool nmethod_needs_unregister = false;
 {
 // invalidate osr nmethod before acquiring the patching lock since
 // they both acquire leaf locks and we don't want a deadlock.
 // This logic is equivalent to the logic below for patching the
 // verified entry point of regular methods.
 if (is_in_use()) {
 // It's a true state change, so mark the method as decompiled.
 // Do it only for transition from alive.
 inc_decompile_count();
+}
+// If the state is becoming a zombie, signal to unregister the nmethod with
+// the heap.
+// 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;
 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
 {
 // Flushing dependecies must be done before any possible
 // safepoint can sneak in, otherwise the oops used by the
 // dependency logic could have become stale.
 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
+if (nmethod_needs_unregister) {
+Universe::heap()->unregister_nmethod(this);
+}
 flush_dependencies(NULL);
 }
 // zombie only - if a JVMTI agent has enabled the CompiledMethodUnload
 // event and it hasn't already been reported for this nmethod then
 #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) {
 ResourceMark m;
 tty->print_cr("nmethod <" INTPTR_FORMAT "> %s code made %s", this, this->method()->name_and_sig_as_C_string(), (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
 // Call function Method*, not embedded in these other places.
 if (_method != NULL) f(_method);
 }
+void nmethod::oops_do(OopClosure* f, bool allow_zombie) {
-// This method is called twice during GC -- once while
-// tracing the "active" nmethods on thread stacks during
-// the (strong) marking phase, and then again when walking
-// the code cache contents during the weak roots processing
-// phase. The two uses are distinguished by means of the
-// 'do_strong_roots_only' flag, which is true in the first
-// case. We want to walk the weak roots in the nmethod
-// only in the second case. The weak roots in the nmethod
-// are the oops in the ExceptionCache and the InlineCache
-// oops.
-void nmethod::oops_do(OopClosure* f, bool do_strong_roots_only) {
 // make sure the oops ready to receive visitors
-assert(!is_zombie() && !is_unloaded(),
+assert(allow_zombie || !is_zombie(), "should not call follow on zombie nmethod");
-"should not call follow on zombie or unloaded nmethod");
+assert(!is_unloaded(), "should not call follow on unloaded nmethod");
 // If the method is not entrant or zombie then a JMP is plastered over the
 // first few bytes.  If an oop in the old code was there, that oop
 // should not get GC'd.  Skip the first few bytes of oops on
 // not-entrant methods.
 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 > hg > graal-compiler

comparison src/share/vm/code/nmethod.cpp @ 12355:cefad50507d8