Lines Matching refs:to
16 * 2 along with this work; if not, write to the Free Software Foundation,
117 // (In the latter two cases, they like other stats are printed to the log only.)
120 // These variables are put into one block to reduce relocations
121 // and make it simpler to print from the debugger.
189 int pc_desc_queries; // queries to nmethod::find_pc_desc
271 // These methods are private, and used to manipulate the exception cache
319 // In order to prevent race conditions do not load cache elements
384 assert(curr != NULL, "nothing to remove");
405 // We never grab a lock to read the exception cache, so we may
423 // we don't lock during reads, it is possible to have several threads attempt
424 // to update the cache with the same data. We need to check for already inserted
598 // This allows the dependency checking code to simply walk the
600 // which are dependent on those classes. The slow way is to
686 // This output goes directly to the tty, not the compiler log.
687 // To enable tools to match it up with the compilation activity,
688 // be sure to tag this tty output with the compile ID.
765 // This output goes directly to the tty, not the compiler log.
766 // To enable tools to match it up with the compilation activity,
767 // be sure to tag this tty output with the compile ID.
866 // Copy contents of ScopeDescRecorder to nmethod
877 // Copy contents of ExceptionHandlerTable to nmethod
881 // we use the information of entry points to find out if a method is
897 // Print a short set of xml attributes to identify this nmethod. The
997 // Promote one word from an assembly-time handle to a live embedded oop.
1000 // As a special case, IC oops are initialized to 1 or -1.
1018 // Now we can fix up all the oops in the code. We need to do this
1021 // CodeBlob constructor, so it is valid even at this early point to
1118 // This means that the low_boundary is going to be a little too high.
1120 // In fact, why are we bothering to look at oops in a non-entrant method??
1123 // Find all calls in an nmethod, and clear the ones that points to zombie methods
1131 // Ok, to lookup references to zombies here
1135 // Clean inline caches pointing to both zombie and not_entrant methods
1145 // Clean inline caches pointing to both zombie and not_entrant methods
1157 // Set the traversal mark to ensure that the sweeper does 2
1158 // cleaning passes before moving to zombie.
1162 // Tell if a non-entrant method can be converted to a zombie (i.e.,
1191 // recorded in instanceKlasses get flushed and pass non-NULL closure to
1211 // If _method is already NULL the methodOop is about to be unloaded,
1212 // so we don't have to break the cycle. Note that it is possible to
1214 // it is pointing to some oop (other than the methodOop) being unloaded.
1216 // OSR methods point to the methodOop, but the methodOop does not
1226 // Transitioning directly from live to unloaded -- so
1227 // we need to force a cache clean-up; remember this
1288 // This logic is equivalent to the logic below for patching the
1300 // to do, but return false to indicate this.
1324 // We need to check if both the _code and _from_compiled_code_entry_point
1325 // refer to this nmethod because there is a race in setting these two fields
1327 // If the vep() points to the zombie nmethod, the memory for the nmethod
1344 // state will be flushed later when the transition to zombie
1359 // we no longer go to a safepoint here.
1363 // It's no longer safe to access the oops section since zombie
1368 assert(state == not_entrant, "other cases may need to be handled differently");
1375 // Make sweeper aware that there is a zombie method that needs to be removed
1396 // We need to deallocate any ExceptionCache data.
1397 // Note that we do not need to grab the nmethod lock for this, it
1428 // First, when a nmethod transitions to a zombie all dependents need
1429 // to be clear. Since zombification happens at a safepoint there's no
1449 // During GC the is_alive closure is non-NULL, and is used to
1450 // determine liveness of dependees that need to be updated.
1480 // No actual classes need to be unloaded in order for this to occur.
1489 // Transfer information from compilation to jvmti
1537 // During unloading we transition to unloaded and then to zombie
1550 // that the jmethodID is a weak reference to the methodOop so if
1551 // it's being unloaded there's no way to look it up since the weak
1559 // Don't want to take the queueing lock. Add it as pending and
1571 // attempt to report the event in the unlikely scenario where the
1577 // GC to unload an nmethod if it contains otherwise unreachable
1582 // Make sure the oop's ready to receive visitors
1598 // to no longer be true. See jvmtiExport.hpp for details.
1603 // call to post_compiled_method_unload() so that the unloading
1627 // clear ICs where the cached oop is referring to an unloaded klass or method.
1684 // refer to marked oops.
1705 // case. We want to walk the weak roots in the nmethod
1710 // make sure the oops ready to receive visitors
1772 // Claim this nmethod for this thread to mark.
1777 // Atomically append this nmethod (now claimed) to the head of the list:
1800 // may fork a bunch of threads, and we need them all to see the same state.
1856 // Method that knows how to preserve outgoing arguments at call. This method must be
1857 // called with a frame corresponding to a Java invoke
1883 inline bool includes(void* p, void* from, void* to) {
1884 return from <= p && p < to;
1928 // If it fails, change the logic to always allocate a multiple
1946 NOT_PRODUCT(--nmethod_stats.pc_desc_tests); // don't count this call to match_desc
1959 // Finds a PcDesc with real-pc equal to "pc"
1979 // (Use a fixed radix to avoid expensive affine pointer arithmetic.)
2120 // an active nmethod => use cpc to determine a return address
2148 // make sure you didn't forget to adjust the filler fields
2183 // (a) the given PC belongs to a nmethod and
2318 // Right now there is no way to find out which entries support
2353 // Actually look inside, to verify the claim that it's clean.
2671 // which are tied to the byte after a call are printed with the call itself.
2762 st->print("; implicit exception: dispatches to " INTPTR_FORMAT, code_begin() + cont_offset);