1.1 --- a/src/share/vm/code/nmethod.cpp Fri Sep 18 09:57:47 2009 -0700 1.2 +++ b/src/share/vm/code/nmethod.cpp Wed Sep 23 23:56:15 2009 -0700 1.3 @@ -1100,6 +1100,10 @@ 1.4 if (!Universe::heap()->is_gc_active()) 1.5 cause->klass()->print(); 1.6 } 1.7 + // Unlink the osr method, so we do not look this up again 1.8 + if (is_osr_method()) { 1.9 + invalidate_osr_method(); 1.10 + } 1.11 // If _method is already NULL the methodOop is about to be unloaded, 1.12 // so we don't have to break the cycle. Note that it is possible to 1.13 // have the methodOop live here, in case we unload the nmethod because 1.14 @@ -1170,7 +1174,7 @@ 1.15 // will never be used anymore. That the nmethods only gets removed when class unloading 1.16 // happens, make life much simpler, since the nmethods are not just going to disappear 1.17 // out of the blue. 1.18 - if (is_osr_only_method()) { 1.19 + if (is_osr_method()) { 1.20 if (osr_entry_bci() != InvalidOSREntryBci) { 1.21 // only log this once 1.22 log_state_change(state); 1.23 @@ -1549,6 +1553,17 @@ 1.24 #endif // !PRODUCT 1.25 } 1.26 1.27 +// This method is called twice during GC -- once while 1.28 +// tracing the "active" nmethods on thread stacks during 1.29 +// the (strong) marking phase, and then again when walking 1.30 +// the code cache contents during the weak roots processing 1.31 +// phase. The two uses are distinguished by means of the 1.32 +// do_nmethods() method in the closure "f" below -- which 1.33 +// answers "yes" in the first case, and "no" in the second 1.34 +// case. We want to walk the weak roots in the nmethod 1.35 +// only in the second case. The weak roots in the nmethod 1.36 +// are the oops in the ExceptionCache and the InlineCache 1.37 +// oops. 1.38 void nmethod::oops_do(OopClosure* f) { 1.39 // make sure the oops ready to receive visitors 1.40 assert(!is_zombie() && !is_unloaded(), 1.41 @@ -1567,19 +1582,25 @@ 1.42 1.43 // Compiled code 1.44 f->do_oop((oop*) &_method); 1.45 - ExceptionCache* ec = exception_cache(); 1.46 - while(ec != NULL) { 1.47 - f->do_oop((oop*)ec->exception_type_addr()); 1.48 - ec = ec->next(); 1.49 - } 1.50 + if (!f->do_nmethods()) { 1.51 + // weak roots processing phase -- update ExceptionCache oops 1.52 + ExceptionCache* ec = exception_cache(); 1.53 + while(ec != NULL) { 1.54 + f->do_oop((oop*)ec->exception_type_addr()); 1.55 + ec = ec->next(); 1.56 + } 1.57 + } // Else strong roots phase -- skip oops in ExceptionCache 1.58 1.59 RelocIterator iter(this, low_boundary); 1.60 + 1.61 while (iter.next()) { 1.62 if (iter.type() == relocInfo::oop_type ) { 1.63 oop_Relocation* r = iter.oop_reloc(); 1.64 // In this loop, we must only follow those oops directly embedded in 1.65 // the code. Other oops (oop_index>0) are seen as part of scopes_oops. 1.66 - assert(1 == (r->oop_is_immediate()) + (r->oop_addr() >= oops_begin() && r->oop_addr() < oops_end()), "oop must be found in exactly one place"); 1.67 + assert(1 == (r->oop_is_immediate()) + 1.68 + (r->oop_addr() >= oops_begin() && r->oop_addr() < oops_end()), 1.69 + "oop must be found in exactly one place"); 1.70 if (r->oop_is_immediate() && r->oop_value() != NULL) { 1.71 f->do_oop(r->oop_addr()); 1.72 }