parse1.cpp revision 991
844N/A * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved. 0N/A * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 0N/A * This code is free software; you can redistribute it and/or modify it 0N/A * under the terms of the GNU General Public License version 2 only, as 0N/A * published by the Free Software Foundation. 0N/A * This code is distributed in the hope that it will be useful, but WITHOUT 0N/A * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 0N/A * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 0N/A * version 2 for more details (a copy is included in the LICENSE file that 0N/A * accompanied this code). 0N/A * You should have received a copy of the GNU General Public License version 0N/A * 2 along with this work; if not, write to the Free Software Foundation, 0N/A * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 0N/A * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 0N/A * CA 95054 USA or visit www.sun.com if you need additional information or 0N/A * have any questions. 0N/A#
include "incls/_precompiled.incl" 0N/A// Static array so we can figure out which bytecodes stop us from compiling 0N/A// and eventually should be encapsulated in a proper class (gri 8/18/98). 0N/A//------------------------------print_statistics------------------------------- 0N/A//------------------------------ON STACK REPLACEMENT--------------------------- 0N/A// Construct a node which can be used to get incoming state for 0N/A// on stack replacement. 0N/A // Very similar to LoadNode::make, except we handle un-aligned longs and 0N/A // doubles on Sparc. Intel can handle them just fine directly. 0N/A switch(
bt ) {
// Signature is flattened 0N/A // Since arguments are in reverse order, the argument address 'adr' 0N/A// Helper routine to prevent the interpreter from handing 0N/A// unexpected typestate to an OSR method. 0N/A// The Node l is a value newly dug out of the interpreter frame. 0N/A// The type is the type predicted by ciTypeFlow. Note that it is 0N/A// not a general type, but can only come from Type::get_typeflow_type. 0N/A// The safepoint is a map which will feed an uncommon trap. 0N/A // TypeFlow may assert null-ness if a type appears unloaded. 0N/A // Value must be null, not a real oop. 0N/A // Typeflow can also cut off paths from the CFG, based on 0N/A // types which appear unloaded, or call sites which appear unlinked. 0N/A // When paths are cut off, values at later merge points can rise 0N/A // toward more specific classes. Make sure these specific classes 0N/A // are still in effect. 0N/A // TypeFlow asserted a specific object type. Value must have that type. 0N/A// Helper routine which sets up elements of the initial parser map when 0N/A// performing a parse for on stack replacement. Add values into map. 0N/A// The only parameter contains the address of a interpreter arguments. 0N/A // Mismatch between method and jvms can occur since map briefly held 0N/A // an OSR entry state (which takes up one RawPtr word). 0N/A // Find the start block. 0N/A // Set initial stack depth. 0N/A // Check bailouts. We currently do not perform on stack replacement 0N/A // of loops in catch blocks or loops which branch with a non-empty stack. 0N/A // Do not OSR inside finally clauses: 0N/A // Commute monitors from interpreter frame to compiler frame. 0N/A // Make a BoxLockNode for the monitor. 0N/A // Displaced headers and locked objects are interleaved in the 0N/A // temp OSR buffer. We only copy the locked objects out here. 0N/A // Fetch the locked object from the OSR temp buffer and copy to our fastlock node. 0N/A // Try and copy the displaced header to the BoxNode 0N/A // Build a bogus FastLockNode (no code will be generated) and push the 0N/A // monitor into our debug info. 0N/A // If the lock is our method synchronization lock, tuck it away in 0N/A // _sync_lock for return and rethrow exit paths. 991N/A // Use the raw liveness computation to make sure that unexpected 991N/A // values don't propagate into the OSR frame. 0N/A // Degenerate or breakpointed method. 0N/A // Extract the needed locals from the interpreter frame. 0N/A // find all the locals that the interpreter thinks contain live oops 0N/A // 6403625: Verify that the interpreter oopMap thinks that the oop is live 0N/A // else we might load a stale oop if the MethodLiveness disagrees with the 0N/A // result of the interpreter. If the interpreter says it is dead we agree 0N/A // by making the value go to top. 0N/A // and ignore it for the loads 0N/A // Filter out TOP, HALF, and BOTTOM. (Cf. ensure_phi.) 0N/A // If the type falls to bottom, then this must be a local that 0N/A // is mixing ints and oops or some such. Forcing it to top 0N/A // makes it go dead. 0N/A // Construct code to access the appropriate local. 0N/A // Extract the needed stack entries from the interpreter frame. 0N/A // Currently the compiler bails out when attempting to on stack replace 0N/A // at a bci with a non-empty stack. We should not reach here. 0N/A // End the OSR migration 0N/A // Now that the interpreter state is loaded, make sure it will match 0N/A // at execution time what the compiler is expecting now: 0N/A // skip type check for dead oops 0N/A // Build an uncommon trap here, if any inputs can be unexpected. 0N/A // The unexpected type happens because a new edge is active 0N/A // in the CFG, which typeflow had previously ignored. 0N/A // E.g., Object x = coldAtFirst() && notReached()? "str": new Integer(123). 0N/A // This x will be typed as Integer if notReached is not yet linked. 0N/A//------------------------------Parse------------------------------------------ 0N/A// Main parser constructor. 0N/A // Init some variables 0N/A // Make sure I have an inline tree, so I can print messages about it. 0N/A // Accumulate deoptimization counts. 0N/A // (The range_check and store_check counts are checked elsewhere.) 0N/A // Saturate the add if it overflows. 0N/A log->
elem(
"observe trap='%s' count='%d' total='%d'",
0N/A // Accumulate total sum of decompilations, also. 0N/A log->
elem(
"observe that='has_exception_handlers'");
0N/A // Always register dependence if JVMTI is enabled, because 0N/A // either breakpoint setting or hotswapping of methods may 0N/A // cause deoptimization. 0N/A // Do some special top-level things. 0N/A _tf = C->
tf();
// the OSR entry type is different 0N/A "Must invalidate if TypeFuncs differ");
0N/A // add method size here to guarantee that inlined methods are added too 0N/A // Import the results of the ciTypeFlow. 0N/A // Merge point for all normal exits 0N/A // Setup the initial JVM state map. 0N/A // Check for bailouts during map initialization 0N/A // Collect debug info for inlined calls unless -XX:-DebugInlinedCalls. 0N/A // Check for bailouts during method entry. 0N/A // We begin parsing as if we have just encountered a jump to the 0N/A // Parse all the basic blocks. 0N/A // Check for bailouts during conversion to graph 0N/A // Fix up all exiting control flow. 0N/A//---------------------------do_all_blocks------------------------------------- 367N/A // Walk over all blocks in Reverse Post-Order. 367N/A // Dead block, no state reaches this block 367N/A // Prepare to parse this block. 367N/A // Not all preds have been parsed. We must build phis everywhere. 367N/A // (Note that dead locals do not get phis built, ever.) 367N/A // Leave behind an undisturbed copy of the map, for future merges. 367N/A // In the absence of irreducible loops, the Region and Phis 367N/A // associated with a merge that doesn't involve a backedge can 605N/A // be simplified now since the RPO parsing order guarantees 367N/A // that any path which was supposed to reach here has already 367N/A // been parsed or must be dead. 367N/A // with irreducible loops multiple passes might be necessary to parse everything 0N/A // Make sure there are no half-processed blocks remaining. 0N/A // Every remaining unprocessed block is dead and may be ignored now. 0N/A//-------------------------------build_exits---------------------------------- 0N/A// Build normal and exceptional exit merge points. 0N/A // make a clone of caller to prevent sharing of side-effects 0N/A // Note: iophi and memphi are not transformed until do_exits. 0N/A // Add a return value to the exit state. (Do not push it yet.) 0N/A // Don't "bind" an unloaded return klass to the ret_phi. If the klass 0N/A // becomes loaded during the subsequent parsing, the loaded and unloaded 0N/A // types will not join when we transform and push in do_exits(). 0N/A // Note: ret_phi is not yet pushed, until do_exits. 0N/A//----------------------------build_start_state------------------------------- 0N/A// Construct a state which contains only the incoming arguments from an 0N/A// unknown caller. The method & bci will be NULL & InvocationEntryBci. 0N/A // Record all these guys for later GVN. 0N/A//-----------------------------make_node_notes--------------------------------- 0N/A//--------------------------return_values-------------------------------------- 0N/A // Add zero or 1 return values 0N/A // Note: The second dummy edge is not needed by a ReturnNode. 0N/A//------------------------rethrow_exceptions----------------------------------- 0N/A// Bind all exception states in the list into a single RethrowNode. 0N/A // Load my combined exception state into the kit, with all phis transformed: 0N/A // like a return but with exception input 0N/A assert(
false,
"unexpected bytecode produced an exception");
0N/A//---------------------------do_exceptions------------------------------------- 0N/A// Process exceptions arising from the current bytecode. 0N/A// Send caught exceptions to the proper handler within this method. 0N/A// Unhandled exceptions feed into _exit. 0N/A // Pop them all off and throw them away. 0N/A // Make sure we can classify this bytecode if we need to. 0N/A // Common case: Transfer control outward. 0N/A // Doing it this early allows the exceptions to common up 0N/A // even between adjacent method calls. 0N/A // Have to look at the exception first. 0N/A // We now return to our regularly scheduled program: 0N/A//---------------------------throw_to_exit------------------------------------- 0N/A// Merge the given map into an exception exit from this method. 0N/A// The exception exit will handle any unlocking of receiver. 0N/A// The ex_oop must be saved within the ex_map, unlike merge_exception. 0N/A // Pop the JVMS to (a copy of) the caller. 0N/A // Copy out the standard machine state: 0N/A // ...and the exception: 0N/A // Finally, collect the new exception state in my exits: 0N/A//------------------------------do_exits--------------------------------------- 0N/A // Now peephole on the return bits 0N/A // This method (which must be a constructor by the rules of Java) 0N/A // wrote a final. The effects of all initializations must be 0N/A // committed to memory before any code after the constructor 0N/A // publishes the reference to the newly constructor object. 0N/A // Rather than wait for the publication, we simply block the 0N/A // writes here. Rather than put a barrier on only those writes 0N/A // which are required to complete, we force all writes to complete. 0N/A // "All bets are off" unless the first publication occurs after a 0N/A // normal return from the constructor. We do not attempt to detect 0N/A // such unusual early publications. But no barrier is needed on 0N/A // exceptional returns, since they cannot publish normally. 0N/A // transform each slice of the original memphi: 0N/A // Note: Logic for creating and optimizing the ReturnNode is in Compile. 0N/A // Unlock along the exceptional paths. 0N/A // This is done late so that we can common up equivalent exceptions 0N/A // (e.g., null checks) arising from multiple points within this method. 0N/A // See GraphKit::add_exception_state, which performs the commoning. 0N/A // record exit from a method if compiled while Dtrace is turned on. 0N/A // First move the exception list out of _exits: 0N/A // Now re-collect the exceptions into _exits: 0N/A // Force the exiting JVM state to have this method at InvocationEntryBci. 0N/A // The exiting JVM state is otherwise a copy of the calling JVMS. 0N/A // Done with exception-path processing. 0N/A // Pop the last vestige of this method: 0N/A // Capture very early exceptions (receiver null checks) from caller JVMS 0N/A//-----------------------------create_entry_map------------------------------- 0N/A// Initialize our parser map to contain the types at method entry. 0N/A// For OSR, the map contains a single RawPtr parameter. 0N/A// Initial monitor locking for sync. methods is performed by do_method_entry. 0N/A // Check for really stupid bail-out cases. 0N/A // If this is an inlined method, we may have to do a receiver null check. 0N/A // Create an initial safepoint to hold JVM state during parsing 0N/A // Pass thru the predefined input parameters. 0N/A // Insert the memory aliasing node 0N/A // Now add the locals which are initially bound to arguments: 0N/A // Clear out the rest of the map (locals and stack) 0N/A//-----------------------------do_method_entry-------------------------------- 0N/A// Emit any code needed in the pseudo-block before BCI zero. 0N/A// The main thing to do is lock the receiver of a synchronized method. 0N/A // If the method is synchronized, we need to construct a lock node, attach 0N/A // it to the Start node, and pin it there. 0N/A // Insert a FastLockNode right after the Start which takes as arguments 0N/A // the current thread pointer, the "this" pointer & the address of the 0N/A // stack slot pair used for the lock. The "this" pointer is a projection 0N/A // off the start node, but the locking spot has to be constructed by 0N/A // creating a ConLNode of 0, and boxing it with a BoxLockNode. The BoxLockNode 0N/A // becomes the second argument to the FastLockNode call. The 0N/A // FastLockNode becomes the new control parent to pin it to the start. 0N/A // Setup Object Pointer 0N/A }
else {
// Else pass the "this" pointer, 0N/A // Clear out dead values from the debug info. 0N/A // Build the FastLockNode 0N/A//------------------------------init_blocks------------------------------------ 0N/A // Create the blocks. 0N/A // Initialize the structs. 0N/A // Collect predecessor and successor information. 0N/A//-------------------------------init_node------------------------------------- 0N/A // entry point has additional predecessor 0N/A//-------------------------------init_graph------------------------------------ 0N/A // Create the successor list for this parser block. 0N/A // Accumulate pred info for the other block, too. 0N/A // A block's successors must be distinguishable by BCI. 0N/A // That is, no bytecode is allowed to branch to two different 0N/A // clones of the same code location. 0N/A for (
int j = 0; j < i; j++) {
0N/A // Note: We never call next_path_num along exception paths, so they 0N/A // never get processed as "ready". Also, the input phis of exception 0N/A // handlers get specially processed, so that 0N/A//---------------------------successor_for_bci--------------------------------- 0N/A // We can actually reach here if ciTypeFlow traps out a block 0N/A // due to an unloaded class, and concurrently with compilation the 0N/A // class is then loaded, so that a later phase of the parser is 0N/A // able to see more of the bytecode CFG. Or, the flow pass and 0N/A // the parser can have a minor difference of opinion about executability 0N/A // of bytecodes. For example, "obj.field = null" is executable even 0N/A // if the field's type is an unloaded class; the flow pass used to 0N/A // make a trap for such code. 0N/A//-----------------------------stack_type_at----------------------------------- 0N/A//-----------------------------local_type_at----------------------------------- 0N/A // Make dead locals fall to bottom. 0N/A // This bitmap can be zero length if we saw a breakpoint. 0N/A // In such cases, pretend they are all live. 0N/A//----------------------------name_for_bc-------------------------------------- 0N/A// helper method for BytecodeParseHistogram 0N/A//----------------------------BytecodeParseHistogram------------------------------------ 0N/A//----------------------------current_count------------------------------------ 0N/A//----------------------------initialized-------------------------------------- 0N/A//----------------------------reset-------------------------------------------- 0N/A//----------------------------set_initial_state-------------------------------- 0N/A// Record info when starting to parse one bytecode 0N/A//----------------------------record_change-------------------------------- 0N/A// Record results of parsing one bytecode 0N/A//----------------------------print-------------------------------------------- 0N/A tty->
cr();
//0123456789012345678901234567890123456789012345678901234567890123456789 0N/A tty->
print_cr(
"nodes : Average number of nodes constructed per bytecode");
0N/A tty->
print_cr(
"rnodes : Significance towards total nodes constructed, (nodes*relative)");
0N/A tty->
print_cr(
"transforms: Average amount of tranform progress per bytecode compiled");
0N/A tty->
print_cr(
"values : Average number of node values improved per bytecode");
0N/A tty->
print_cr(
" absolute relative nodes rnodes transforms values name");
0N/A tty->
print_cr(
"----------------------------------------------------------------------");
0N/A tty->
print_cr(
"----------------------------------------------------------------------");
0N/A tty->
print_cr(
"----------------------------------------------------------------------");
0N/A//----------------------------load_state_from---------------------------------- 0N/A // load the block's JVM state: 0N/A//-----------------------------record_state------------------------------------ 0N/A//------------------------------do_one_block----------------------------------- 0N/A tty->
print(
"Parsing block #%d at bci [%d,%d), successors: ",
0N/A for (
int i = 0; i <
nt; i++) {
0N/A // Set iterator to start of block. 0N/A // Learn the current bci from the iterator: 0N/A // Do not walk into the next block until directed by do_all_blocks. 0N/A // Output an optional context marker, to help place actions 0N/A // that occur during parsing of this BC. If there is no log 0N/A // output until the next context string, this context string 0N/A // will be silently ignored. 0N/A // We must respect the flow pass's traps, because it will refuse 0N/A // to produce successors for trapping blocks. 0N/A // Fall into next bytecode. Each bytecode normally has 1 sequential 0N/A // successor which is typically made ready by visiting this bytecode. 0N/A // If the successor has several predecessors, then it is a merge 0N/A // point, starts a new basic block, and is handled like other basic blocks. 0N/A//------------------------------merge------------------------------------------ 0N/A // Collect debug info for inlined calls unless -XX:-DebugInlinedCalls. 0N/A // Update the JVMS annotation, if present. 0N/A//------------------------------merge------------------------------------------ 0N/A// Merge the current mapping into the basic block starting at bci 0N/A//-------------------------merge_new_path-------------------------------------- 0N/A// Merge the current mapping into the basic block, using a new path 0N/A//-------------------------merge_exception------------------------------------- 0N/A// Merge the current mapping into the basic block starting at bci 0N/A// The ex_oop must be pushed on the stack, unlike throw_to_exit. 0N/A assert(
sp() ==
1,
"must have only the throw exception on the stack");
0N/A//--------------------handle_missing_successor--------------------------------- 0N/A//--------------------------merge_common--------------------------------------- 0N/A // Zap extra stack slots to top 0N/A // If this path is dead, do not bother capturing it as a merge. 0N/A // It is "as if" we had 1 fewer predecessors from the beginning. 0N/A // Record that a new block has been merged. 0N/A // Make a region if we know there are multiple or unpredictable inputs. 0N/A // (Also, if this is a plain fall-through, we might see another region, 0N/A // which must not be allowed into this block's map.) 0N/A // Add a Region to start the new basic block. Phis will be added 0N/A // zap all inputs to NULL for debugging (done in Node(uint) constructor) 0N/A // for (int j = 1; j < edges+1; j++) { r->init_req(j, NULL); } 0N/A // Convert the existing Parser mapping into a mapping at this bci. 0N/A }
else {
// Prior mapping at this bci 0N/A // We must not manufacture more phis if the target is already parsed. 0N/A // Iterate over my current mapping and the old mapping. 0N/A // Where different, insert Phi functions. 0N/A // Use any existing Phi functions. 0N/A // Compute where to merge into 0N/A // Merge incoming control path 0N/A if (
pnum ==
1) {
// Last merge for this Region? 0N/A // Update all the non-control inputs to map: 0N/A if (m != n) {
// Different; must merge 0N/A // Frame pointer and Return Address never changes 0N/A default:
// All normal stuff 0N/A // At this point, n might be top if: 0N/A // - there is no phi (because TypeFlow detected a conflict), or 0N/A // - the corresponding control edges is top (a dead incoming path) 0N/A // It is a bug if we create a phi which sees a garbage value on a live path. 0N/A // Last merge for this Phi. 0N/A // So far, Phis have had a reasonable type from ciTypeFlow. 0N/A // Now _gvn will join that with the meet of current inputs. 0N/A // BOTTOM is never permissible here, 'cause pessimistically 0N/A // Phis of pointers cannot lose the basic pointer type. 0N/A }
// End of for all values to be merged 0N/A !r->
in(0)) {
// The occasional useless Region 0N/A // newin has been subsumed into the lazy merge, and is now dead. 0N/A stop();
// done with this guy, for now 0N/A // Done with this parser state. 0N/A//--------------------------merge_memory_edges--------------------------------- 0N/A // (nophi means we must not create phis, because we already parsed here) 0N/A // Merge the inputs to the MergeMems 0N/A // Trouble: No new splits allowed after a loop body is parsed. 0N/A // Instead, wire the new split into a MergeMem on the backedge. 0N/A // The optimizer will sort it out, slicing the phi. 0N/A // Insert q into local phi 0N/A // Transform base last, in case we must fiddle with remerging. 0N/A//------------------------ensure_phis_everywhere------------------------------- 0N/A // Ensure a phi on all currently known memories. 0N/A // Note: This is our only chance to create phis for memory slices. 0N/A // If we miss a slice that crops up later, it will have to be 0N/A // merged into the base-memory phi that we are building here. 0N/A // Later, the optimizer will comb out the knot, and build separate 0N/A // phi-loops for each memory slice that matters. 0N/A // Monitors must nest nicely and not get confused amongst themselves. 0N/A // Phi-ify everything up to the monitors, though. 0N/A // Even monitors need Phis, though they are well-structured. 0N/A // This is true for OSR methods, and also for the rare cases where 0N/A // a monitor object is the subject of a replace_in_map operation. 0N/A // See bugs 4426707 and 5043395. 0N/A//-----------------------------add_new_path------------------------------------ 0N/A// Add a previously unaccounted predecessor to this block. 0N/A // If there is no map, return the lowest unused path number. 0N/A // Add new path to the region. 0N/A // Ensure a phi on all currently known memories. 0N/A//------------------------------ensure_phi------------------------------------- 0N/A// Turn the idx'th entry of the current map into a Phi 0N/A if (o ==
top())
return NULL;
// TOP always merges into TOP 0N/A // Now use a Phi here for merging 0N/A assert(
false,
"no type information for this phi");
0N/A // If the type falls to bottom, then this must be a local that 0N/A // is mixing ints and oops or some such. Forcing it to top 0N/A // makes it go dead. 0N/A // Do not create phis for top either. 0N/A // A top on a non-null control flow must be an unused even after the.phi. 0N/A//--------------------------ensure_memory_phi---------------------------------- 0N/A// Turn the idx'th slice of the current memory into a Phi 0N/A // clone the shared base memory phi to make a new memory split 0N/A // Now use a Phi here for merging 0N/A//------------------------------call_register_finalizer----------------------- 0N/A// Check the klass of the receiver and call register_finalizer if the 0N/A// class need finalization. 0N/A "must have non-null instance type");
0N/A // The type isn't known exactly so see if CHA tells us anything. 0N/A // No finalizable subclasses so skip the dynamic check. 0N/A // Insert a dynamic test for whether the instance needs 0N/A // finalization. In general this will fold up since the concrete 0N/A // class is often visible so the access flags are constant. 0N/A // There is no slow path. 0N/A // These two phis are pre-filled with copies of of the fast IO and Memory 0N/A//------------------------------return_current--------------------------------- 0N/A// Append current _map to _exit_return 0N/A // Do not set_parse_bci, so that return goo is credited to the return insn. 0N/A // get a copy of the base memory, and patch just this one input 0N/A // frame pointer is always same, already captured 0N/A // If returning oops to an interface-return, there is a silent free 0N/A // cast from oop to interface allowed by the Verifier. Make it explicit 0N/A // sharpen the type eagerly; this eases certain assert checking 0N/A//------------------------------add_safepoint---------------------------------- 0N/A // See if we can avoid this safepoint. No need for a SafePoint immediately 0N/A // after a Call (except Leaf Call) or another SafePoint. 0N/A // Clear out dead values from the debug info. 0N/A // Clone the JVM State 0N/A // Capture memory state BEFORE a SafePoint. Since we can block at a 0N/A // SafePoint we need our GC state to be safe; i.e. we need all our current 0N/A // write barriers (card marks) to not float down after the SafePoint so we 0N/A // must read raw memory. Likewise we need all oop stores to match the card 0N/A // marks. If deopt can happen, we need ALL stores (we need the correct JVM 0N/A // state on a deopt). 0N/A // We do not need to WRITE the memory state after a SafePoint. The control 0N/A // edge will keep card-marks and oop-stores from floating up from below a 0N/A // SafePoint and our true dependency added here will keep them from floating 0N/A // down below a SafePoint. 0N/A // Clone the current memory state 0N/A // Pass control through the safepoint 0N/A // Fix edges normally used by a call 0N/A // Create a node for the polling address 0N/A // Fix up the JVM State edges 0N/A // Provide an edge from root to safepoint. This makes the safepoint 0N/A // appear useful until the parse has completed. 0N/A//------------------------show_parse_info-------------------------------------- 0N/A // Check this is not the final compiled version 0N/A // Print that we succeeded; suppress this message on the first osr parse. 0N/A // Check this is not the final compiled version 0N/A//------------------------------dump------------------------------------------- 0N/A// Dump information associated with the bytecodes of current _method 0N/A // Iterate over bytecodes 0N/A// Dump information associated with a byte code index, 'bci' 0N/A // Output info on merge-points, cloning, and within _jsr..._ret