Lines Matching refs:to
16 * 2 along with this work; if not, write to the Free Software Foundation,
47 BlockList* _bci2block; // mapping from bci to blocks for GraphBuilder
183 // Draws edges from a block to its exception handlers
224 // Without it, backward branches could jump to a bci where no block was created
243 // track stores to local variables for selective creation of phi functions
519 // current value of its fields. Stores of the default value to fields
520 // which have never been stored to before are eliminated since they
568 // we don't know what's being stored to so kill it all.
575 // return true if this value correspond to the default value of a field.
648 // of field info list to be reused later.
701 // It is necessary to clone all blocks associated with a
721 // copy was_visited_flag to allow early detection of bailouts
725 // to a compilation bailout
830 // The XHandlers need to be adjusted to dispatch to the cloned
832 // unlocker needs to be handled specially. The synthetic unlocker
834 // should dispatch to the same one.
923 // We need to do additional tracking of the location of the return
926 // need to bail out.
930 // Also check parent jsrs (if any) at this time to see whether
1096 // try to simplify
1114 // pattern: (a << 0) >>> 0 => simplify to: a
1117 // pattern: (a << s0c) >>> s0c => simplify to: a & m, with m constant
1118 assert(0 < s0c && s0c < BitsPerInt, "adjust code below to handle corner cases");
1149 void GraphBuilder::convert(Bytecodes::Code op, BasicType from, BasicType to) {
1150 push(as_ValueType(to), append(new Convert(op, pop(as_ValueType(from)), as_ValueType(to))));
1194 // At level 2 we need the proper bci to count backedges
1207 // Check if this If was reduced to Goto.
1257 // might end up trying to re-parse a block containing a jsr which
1281 // Rets simply become (NON-SAFEPOINT) gotos to the jsr continuation
1333 // simplify to If
1371 // If the receiver requires finalization then emit code to perform
1429 // Check to see whether we are inlining. If so, Return
1430 // instructions become Gotos to the continuation point.
1442 // released before we jump to the continuation block.
1500 // call will_link again to determine if the field is valid.
1661 // we have to make sure the argument size (incl. the receiver)
1665 // Use raw to get rewritten bytecode.
1680 // check if CHA possible: if so, change the code to invoke_special
1692 // convert them directly to an invokespecial or invokestatic.
1725 // try to find a precise receiver type
1751 // If we have the exact receiver type we can bind directly to
1752 // the method to call.
1767 // Use CHA on the receiver to select a more precise method.
1771 // may be able bind this invoke directly to the implementing
1773 // and on the method we bind to. Additionally since all we know
1774 // about the receiver type is the it's supposed to implement the
1775 // interface we have to insert a check that it's the class we
1777 // they are roughly equivalent to Object.
1784 assert(holder->is_interface(), "invokeinterface to non interface?");
1787 // equal to the number of implementors for target->holder() so
1799 // If CHA is able to bind this invoke then update the class
1800 // to match that class, otherwise klass will refer to the
1828 // by dynamic class loading. Be sure to test the "static" receiver
1829 // dest_method here, as opposed to the actual receiver, which may
1830 // falsely lead us to believe that the receiver is final or private.
1871 // compilation has to be aborted. This is fairly rare and currently
1872 // seems to only occur for jasm-generated classes which contain
1875 // therefore not caught early enough to abort the inlining without
1896 // The UseInlineCaches only controls dispatch to invokevirtuals for
1897 // loaded classes which we weren't able to statically bind.
2102 // Lookup the instruction in the ValueMap and add it to the map if
2121 // want processing to continue normally until it's noticed.
2219 // It's acceptable for an exception handler to cover itself
2221 // very rare so we bailout instead of trying to handle it.
2242 // stacks to not match because blocks can be parsed twice.
2247 BAILOUT_("error while joining with exception handler, prob. due to complicated jsr/rets", exception_handlers);
2253 // add entry to the list of xhandlers of this block
2256 // add back-edge from xhandler entry to this block
2298 // needed to be cloned)
2345 // already tried to simplify phi before
2355 // mark phi function as processed to break cycles in phi functions
2358 // simplify x = [y, x] and x = [y, y] to y
2395 tty->print_cr("simplified phi function %c%d to %c%d (Block B%d)", phi->type()->tchar(), phi->id(), subst->type()->tchar(), subst->id(), phi->block()->block_id());
2417 assert(phi == NULL || phi->block() != b, "must not have phi function to simplify in caller state");
2490 case Bytecodes::_nop : /* nothing to do */ break;
2699 // save current bci to setup Goto at the end
2722 // connect to begin & set state
2751 // we're about to parse the osr entry block, so make sure
2770 // the following bytecodes are assumed to potentially
2899 // create a new block to be the osr setup code
2986 // don't allow T_ARRAY to propagate into locals types
3043 // compiled version which could lead to monotonicity problems on
3063 if (!result) BAILOUT("failed to inline intrinsic");
3086 // Also we need intrinsic to prevent commoning reads from this field
3103 if (!result) BAILOUT("failed to inline intrinsic");
3192 // exclude methods we don't want to inline
3245 // negative filter: should callee NOT be inlined? returns NULL, ok to inline, or rejection msg
3445 // Also to prevent commoning reads from this field across safepoint
3489 // will be replaced with Gotos to this point.
3493 // Note: can not assign state to continuation yet, as we have to
3507 // Must copy state to avoid wrong sharing when parsing bytecodes
3519 // Ready to resume parsing in subroutine
3532 // add continuation to work list instead of parsing it immediately
3555 // guaranteed to be non-null by the explicit null check at the
3642 // first perform tests of things it's not possible to inline
3732 // callee will need to be replaced by Goto's pointing to this
3749 // inlining, to detect if inlined method has edges to its
3819 // Ready to resume parsing in callee (either in the same block we
3834 // At this point we are almost ready to return and resume parsing of
3835 // the caller back in the GraphBuilder. The only thing we want to do
3837 // generated at least one Goto to the continuation block. If we
3839 // one block (and we didn't have to Goto its entry), then we snip
3840 // off the Goto to the continuation, allowing control to fall
3842 // block merging. This allows load elimination and CSE to take place
3844 // is currently essential to making inlining profitable.
3862 // add continuation to work list instead of parsing it immediately
3918 // If the target is another method handle invoke try recursivly to get
3927 // Cast receiver to its type.
3938 // Cast reference arguments to its type.
4026 // Must clone bci2block list as we will be mutating it in order to
4043 // accumulate minimum number of monitor slots to be reserved
4134 // Pop off some args to speically handle, then push back
4156 // cause CSE to invalidate memory across it.