InliningUtil.java revision 12657:6ef01bd40ce2 
1/*
2 * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23package org.graalvm.compiler.phases.common.inlining;
24
25import static org.graalvm.compiler.core.common.GraalOptions.UseGraalInstrumentation;
26import static jdk.vm.ci.meta.DeoptimizationAction.InvalidateReprofile;
27import static jdk.vm.ci.meta.DeoptimizationReason.NullCheckException;
28
29import java.lang.reflect.Constructor;
30import java.util.ArrayList;
31import java.util.HashMap;
32import java.util.List;
33import java.util.Map;
34import java.util.Map.Entry;
35import java.util.function.Function;
36
37import org.graalvm.compiler.api.replacements.MethodSubstitution;
38import org.graalvm.compiler.core.common.type.Stamp;
39import org.graalvm.compiler.core.common.type.StampFactory;
40import org.graalvm.compiler.core.common.type.TypeReference;
41import org.graalvm.compiler.core.common.util.Util;
42import org.graalvm.compiler.debug.Debug;
43import org.graalvm.compiler.debug.Debug.Scope;
44import org.graalvm.compiler.debug.Fingerprint;
45import org.graalvm.compiler.debug.GraalError;
46import org.graalvm.compiler.debug.internal.method.MethodMetricsImpl;
47import org.graalvm.compiler.debug.internal.method.MethodMetricsInlineeScopeInfo;
48import org.graalvm.compiler.graph.GraalGraphError;
49import org.graalvm.compiler.graph.Graph;
50import org.graalvm.compiler.graph.Graph.DuplicationReplacement;
51import org.graalvm.compiler.graph.Node;
52import org.graalvm.compiler.graph.NodeInputList;
53import org.graalvm.compiler.graph.NodeSourcePosition;
54import org.graalvm.compiler.graph.NodeWorkList;
55import org.graalvm.compiler.nodeinfo.Verbosity;
56import org.graalvm.compiler.nodes.AbstractBeginNode;
57import org.graalvm.compiler.nodes.AbstractEndNode;
58import org.graalvm.compiler.nodes.AbstractMergeNode;
59import org.graalvm.compiler.nodes.BeginNode;
60import org.graalvm.compiler.nodes.CallTargetNode;
61import org.graalvm.compiler.nodes.CallTargetNode.InvokeKind;
62import org.graalvm.compiler.nodes.ControlSinkNode;
63import org.graalvm.compiler.nodes.DeoptimizeNode;
64import org.graalvm.compiler.nodes.EndNode;
65import org.graalvm.compiler.nodes.FixedGuardNode;
66import org.graalvm.compiler.nodes.FixedNode;
67import org.graalvm.compiler.nodes.FixedWithNextNode;
68import org.graalvm.compiler.nodes.FrameState;
69import org.graalvm.compiler.nodes.GuardedValueNode;
70import org.graalvm.compiler.nodes.Invoke;
71import org.graalvm.compiler.nodes.InvokeNode;
72import org.graalvm.compiler.nodes.InvokeWithExceptionNode;
73import org.graalvm.compiler.nodes.KillingBeginNode;
74import org.graalvm.compiler.nodes.LogicNode;
75import org.graalvm.compiler.nodes.MergeNode;
76import org.graalvm.compiler.nodes.ParameterNode;
77import org.graalvm.compiler.nodes.PhiNode;
78import org.graalvm.compiler.nodes.PiNode;
79import org.graalvm.compiler.nodes.ReturnNode;
80import org.graalvm.compiler.nodes.StartNode;
81import org.graalvm.compiler.nodes.StateSplit;
82import org.graalvm.compiler.nodes.StructuredGraph;
83import org.graalvm.compiler.nodes.UnwindNode;
84import org.graalvm.compiler.nodes.ValueNode;
85import org.graalvm.compiler.nodes.ValuePhiNode;
86import org.graalvm.compiler.nodes.calc.IsNullNode;
87import org.graalvm.compiler.nodes.debug.instrumentation.InstrumentationNode;
88import org.graalvm.compiler.nodes.extended.ForeignCallNode;
89import org.graalvm.compiler.nodes.extended.GuardingNode;
90import org.graalvm.compiler.nodes.java.ExceptionObjectNode;
91import org.graalvm.compiler.nodes.java.MethodCallTargetNode;
92import org.graalvm.compiler.nodes.java.MonitorExitNode;
93import org.graalvm.compiler.nodes.java.MonitorIdNode;
94import org.graalvm.compiler.nodes.spi.Replacements;
95import org.graalvm.compiler.nodes.type.StampTool;
96import org.graalvm.compiler.nodes.util.GraphUtil;
97import org.graalvm.compiler.phases.common.inlining.info.InlineInfo;
98
99import jdk.vm.ci.code.BytecodeFrame;
100import jdk.vm.ci.meta.Assumptions;
101import jdk.vm.ci.meta.DeoptimizationAction;
102import jdk.vm.ci.meta.DeoptimizationReason;
103import jdk.vm.ci.meta.JavaConstant;
104import jdk.vm.ci.meta.JavaKind;
105import jdk.vm.ci.meta.ResolvedJavaMethod;
106import jdk.vm.ci.meta.ResolvedJavaType;
107
108public class InliningUtil {
109
110    private static final String inliningDecisionsScopeString = "InliningDecisions";
111
112    /**
113     * Print a HotSpot-style inlining message to the console.
114     */
115    private static void printInlining(final InlineInfo info, final int inliningDepth, final boolean success, final String msg, final Object... args) {
116        printInlining(info.methodAt(0), info.invoke(), inliningDepth, success, msg, args);
117    }
118
119    private static void printInlining(final ResolvedJavaMethod method, final Invoke invoke, final int inliningDepth, final boolean success, final String msg, final Object... args) {
120        Util.printInlining(method, invoke.bci(), inliningDepth, success, msg, args);
121    }
122
123    public static void logInlinedMethod(InlineInfo info, int inliningDepth, boolean allowLogging, String msg, Object... args) {
124        logInliningDecision(info, inliningDepth, allowLogging, true, msg, args);
125    }
126
127    public static void logNotInlinedMethod(InlineInfo info, int inliningDepth, String msg, Object... args) {
128        logInliningDecision(info, inliningDepth, true, false, msg, args);
129    }
130
131    public static void logInliningDecision(InlineInfo info, int inliningDepth, boolean allowLogging, boolean success, String msg, final Object... args) {
132        if (allowLogging) {
133            printInlining(info, inliningDepth, success, msg, args);
134            if (shouldLogInliningDecision()) {
135                logInliningDecision(methodName(info), success, msg, args);
136            }
137        }
138    }
139
140    @SuppressWarnings("try")
141    public static void logInliningDecision(final String msg, final Object... args) {
142        try (Scope s = Debug.scope(inliningDecisionsScopeString)) {
143            // Can't use log here since we are varargs
144            if (Debug.isLogEnabled()) {
145                Debug.logv(msg, args);
146            }
147        }
148    }
149
150    public static void logNotInlinedMethod(Invoke invoke, String msg) {
151        if (shouldLogInliningDecision()) {
152            String methodString = invoke.toString();
153            if (invoke.callTarget() == null) {
154                methodString += " callTarget=null";
155            } else {
156                String targetName = invoke.callTarget().targetName();
157                if (!methodString.endsWith(targetName)) {
158                    methodString += " " + targetName;
159                }
160            }
161            logInliningDecision(methodString, false, msg, new Object[0]);
162        }
163    }
164
165    public static void logNotInlined(Invoke invoke, int inliningDepth, ResolvedJavaMethod method, String msg) {
166        logNotInlinedInvoke(invoke, inliningDepth, method, msg, new Object[0]);
167    }
168
169    public static void logNotInlinedInvoke(Invoke invoke, int inliningDepth, ResolvedJavaMethod method, String msg, Object... args) {
170        printInlining(method, invoke, inliningDepth, false, msg, args);
171        if (shouldLogInliningDecision()) {
172            String methodString = methodName(method, invoke);
173            logInliningDecision(methodString, false, msg, args);
174        }
175    }
176
177    private static void logInliningDecision(final String methodString, final boolean success, final String msg, final Object... args) {
178        String inliningMsg = "inlining " + methodString + ": " + msg;
179        if (!success) {
180            inliningMsg = "not " + inliningMsg;
181        }
182        logInliningDecision(inliningMsg, args);
183    }
184
185    @SuppressWarnings("try")
186    public static boolean shouldLogInliningDecision() {
187        try (Scope s = Debug.scope(inliningDecisionsScopeString)) {
188            return Debug.isLogEnabled();
189        }
190    }
191
192    private static String methodName(ResolvedJavaMethod method, Invoke invoke) {
193        if (invoke != null && invoke.stateAfter() != null) {
194            return methodName(invoke.stateAfter(), invoke.bci()) + ": " + method.format("%H.%n(%p):%r") + " (" + method.getCodeSize() + " bytes)";
195        } else {
196            return method.format("%H.%n(%p):%r") + " (" + method.getCodeSize() + " bytes)";
197        }
198    }
199
200    private static String methodName(InlineInfo info) {
201        if (info == null) {
202            return "null";
203        } else if (info.invoke() != null && info.invoke().stateAfter() != null) {
204            return methodName(info.invoke().stateAfter(), info.invoke().bci()) + ": " + info.toString();
205        } else {
206            return info.toString();
207        }
208    }
209
210    private static String methodName(FrameState frameState, int bci) {
211        StringBuilder sb = new StringBuilder();
212        if (frameState.outerFrameState() != null) {
213            sb.append(methodName(frameState.outerFrameState(), frameState.outerFrameState().bci));
214            sb.append("->");
215        }
216        sb.append(frameState.getMethod().format("%h.%n"));
217        sb.append("@").append(bci);
218        return sb.toString();
219    }
220
221    public static void replaceInvokeCallTarget(Invoke invoke, StructuredGraph graph, InvokeKind invokeKind, ResolvedJavaMethod targetMethod) {
222        MethodCallTargetNode oldCallTarget = (MethodCallTargetNode) invoke.callTarget();
223        MethodCallTargetNode newCallTarget = graph.add(new MethodCallTargetNode(invokeKind, targetMethod, oldCallTarget.arguments().toArray(new ValueNode[0]), oldCallTarget.returnStamp(),
224                        oldCallTarget.getProfile()));
225        invoke.asNode().replaceFirstInput(oldCallTarget, newCallTarget);
226    }
227
228    public static GuardedValueNode createAnchoredReceiver(StructuredGraph graph, GuardingNode anchor, ResolvedJavaType commonType, ValueNode receiver, boolean exact) {
229        return createAnchoredReceiver(graph, anchor, receiver,
230                        exact ? StampFactory.objectNonNull(TypeReference.createExactTrusted(commonType)) : StampFactory.objectNonNull(TypeReference.createTrusted(graph.getAssumptions(), commonType)));
231    }
232
233    private static GuardedValueNode createAnchoredReceiver(StructuredGraph graph, GuardingNode anchor, ValueNode receiver, Stamp stamp) {
234        // to avoid that floating reads on receiver fields float above the type check
235        return graph.unique(new GuardedValueNode(receiver, anchor, stamp));
236    }
237
238    /**
239     * @return null iff the check succeeds, otherwise a (non-null) descriptive message.
240     */
241    public static String checkInvokeConditions(Invoke invoke) {
242        if (invoke.predecessor() == null || !invoke.asNode().isAlive()) {
243            return "the invoke is dead code";
244        }
245        if (!(invoke.callTarget() instanceof MethodCallTargetNode)) {
246            return "the invoke has already been lowered, or has been created as a low-level node";
247        }
248        MethodCallTargetNode callTarget = (MethodCallTargetNode) invoke.callTarget();
249        if (callTarget.targetMethod() == null) {
250            return "target method is null";
251        }
252        assert invoke.stateAfter() != null : invoke;
253        if (!invoke.useForInlining()) {
254            return "the invoke is marked to be not used for inlining";
255        }
256        ValueNode receiver = callTarget.receiver();
257        if (receiver != null && receiver.isConstant() && receiver.isNullConstant()) {
258            return "receiver is null";
259        }
260        return null;
261    }
262
263    /**
264     * Performs an actual inlining, thereby replacing the given invoke with the given inlineGraph.
265     *
266     * @param invoke the invoke that will be replaced
267     * @param inlineGraph the graph that the invoke will be replaced with
268     * @param receiverNullCheck true if a null check needs to be generated for non-static inlinings,
269     *            false if no such check is required
270     * @param canonicalizedNodes if non-null then append to this list any nodes which should be
271     *            canonicalized after inlining
272     * @param inlineeMethod the actual method being inlined. Maybe be null for snippets.
273     */
274    @SuppressWarnings("try")
275    public static Map<Node, Node> inline(Invoke invoke, StructuredGraph inlineGraph, boolean receiverNullCheck, List<Node> canonicalizedNodes, ResolvedJavaMethod inlineeMethod) {
276        MethodMetricsInlineeScopeInfo m = MethodMetricsInlineeScopeInfo.create();
277        try (Debug.Scope s = Debug.methodMetricsScope("InlineEnhancement", m, false)) {
278            FixedNode invokeNode = invoke.asNode();
279            StructuredGraph graph = invokeNode.graph();
280            if (Fingerprint.ENABLED) {
281                Fingerprint.submit("inlining %s into %s: %s", formatGraph(inlineGraph), formatGraph(invoke.asNode().graph()), inlineGraph.getNodes().snapshot());
282            }
283            final NodeInputList<ValueNode> parameters = invoke.callTarget().arguments();
284
285            assert inlineGraph.getGuardsStage().ordinal() >= graph.getGuardsStage().ordinal();
286            assert !invokeNode.graph().isAfterFloatingReadPhase() : "inline isn't handled correctly after floating reads phase";
287
288            if (receiverNullCheck && !((MethodCallTargetNode) invoke.callTarget()).isStatic()) {
289                nonNullReceiver(invoke);
290            }
291
292            ArrayList<Node> nodes = new ArrayList<>(inlineGraph.getNodes().count());
293            ArrayList<ReturnNode> returnNodes = new ArrayList<>(4);
294            UnwindNode unwindNode = null;
295            final StartNode entryPointNode = inlineGraph.start();
296            FixedNode firstCFGNode = entryPointNode.next();
297            if (firstCFGNode == null) {
298                throw new IllegalStateException("Inlined graph is in invalid state: " + inlineGraph);
299            }
300            for (Node node : inlineGraph.getNodes()) {
301                if (node == entryPointNode || (node == entryPointNode.stateAfter() && node.usages().count() == 1) || node instanceof ParameterNode) {
302                    // Do nothing.
303                } else {
304                    nodes.add(node);
305                    if (node instanceof ReturnNode) {
306                        returnNodes.add((ReturnNode) node);
307                    } else if (node instanceof UnwindNode) {
308                        assert unwindNode == null;
309                        unwindNode = (UnwindNode) node;
310                    }
311                }
312            }
313
314            final AbstractBeginNode prevBegin = AbstractBeginNode.prevBegin(invokeNode);
315            DuplicationReplacement localReplacement = new DuplicationReplacement() {
316
317                @Override
318                public Node replacement(Node node) {
319                    if (node instanceof ParameterNode) {
320                        return parameters.get(((ParameterNode) node).index());
321                    } else if (node == entryPointNode) {
322                        return prevBegin;
323                    }
324                    return node;
325                }
326            };
327
328            assert invokeNode.successors().first() != null : invoke;
329            assert invokeNode.predecessor() != null;
330
331            Map<Node, Node> duplicates = graph.addDuplicates(nodes, inlineGraph, inlineGraph.getNodeCount(), localReplacement);
332
333            FrameState stateAfter = invoke.stateAfter();
334            assert stateAfter == null || stateAfter.isAlive();
335
336            FrameState stateAtExceptionEdge = null;
337            if (invoke instanceof InvokeWithExceptionNode) {
338                InvokeWithExceptionNode invokeWithException = ((InvokeWithExceptionNode) invoke);
339                if (unwindNode != null) {
340                    ExceptionObjectNode obj = (ExceptionObjectNode) invokeWithException.exceptionEdge();
341                    stateAtExceptionEdge = obj.stateAfter();
342                }
343            }
344
345            updateSourcePositions(invoke, inlineGraph, duplicates);
346            if (stateAfter != null) {
347                processFrameStates(invoke, inlineGraph, duplicates, stateAtExceptionEdge, returnNodes.size() > 1);
348                int callerLockDepth = stateAfter.nestedLockDepth();
349                if (callerLockDepth != 0) {
350                    for (MonitorIdNode original : inlineGraph.getNodes(MonitorIdNode.TYPE)) {
351                        MonitorIdNode monitor = (MonitorIdNode) duplicates.get(original);
352                        processMonitorId(invoke.stateAfter(), monitor);
353                    }
354                }
355            } else {
356                assert checkContainsOnlyInvalidOrAfterFrameState(duplicates);
357            }
358
359            firstCFGNode = (FixedNode) duplicates.get(firstCFGNode);
360            for (int i = 0; i < returnNodes.size(); i++) {
361                returnNodes.set(i, (ReturnNode) duplicates.get(returnNodes.get(i)));
362            }
363            if (unwindNode != null) {
364                unwindNode = (UnwindNode) duplicates.get(unwindNode);
365            }
366
367            if (UseGraalInstrumentation.getValue()) {
368                detachInstrumentation(invoke);
369            }
370            ValueNode returnValue = finishInlining(invoke, graph, firstCFGNode, returnNodes, unwindNode, inlineGraph.getAssumptions(), inlineGraph, canonicalizedNodes);
371            if (canonicalizedNodes != null) {
372                if (returnValue != null) {
373                    for (Node usage : returnValue.usages()) {
374                        canonicalizedNodes.add(usage);
375                    }
376                }
377                for (ParameterNode parameter : inlineGraph.getNodes(ParameterNode.TYPE)) {
378                    for (Node usage : parameter.usages()) {
379                        Node duplicate = duplicates.get(usage);
380                        if (duplicate != null && duplicate.isAlive()) {
381                            canonicalizedNodes.add(duplicate);
382                        }
383                    }
384                }
385            }
386
387            GraphUtil.killCFG(invokeNode);
388
389            if (Debug.isMethodMeterEnabled() && m != null) {
390                MethodMetricsImpl.recordInlinee(m.getRootMethod(), invoke.asNode().graph().method(), inlineeMethod);
391            }
392            return duplicates;
393        }
394    }
395
396    public static ValueNode finishInlining(Invoke invoke, StructuredGraph graph, FixedNode firstNode, List<ReturnNode> returnNodes, UnwindNode unwindNode, Assumptions inlinedAssumptions,
397                    StructuredGraph inlineGraph, List<Node> canonicalizedNodes) {
398        FixedNode invokeNode = invoke.asNode();
399        FrameState stateAfter = invoke.stateAfter();
400        assert stateAfter == null || stateAfter.isAlive();
401
402        invokeNode.replaceAtPredecessor(firstNode);
403
404        if (invoke instanceof InvokeWithExceptionNode) {
405            InvokeWithExceptionNode invokeWithException = ((InvokeWithExceptionNode) invoke);
406            if (unwindNode != null && unwindNode.isAlive()) {
407                assert unwindNode.predecessor() != null;
408                assert invokeWithException.exceptionEdge().successors().count() == 1;
409                ExceptionObjectNode obj = (ExceptionObjectNode) invokeWithException.exceptionEdge();
410                obj.replaceAtUsages(unwindNode.exception());
411                Node n = obj.next();
412                obj.setNext(null);
413                unwindNode.replaceAndDelete(n);
414
415                obj.replaceAtPredecessor(null);
416                obj.safeDelete();
417            } else {
418                invokeWithException.killExceptionEdge();
419            }
420
421            // get rid of memory kill
422            AbstractBeginNode begin = invokeWithException.next();
423            if (begin instanceof KillingBeginNode) {
424                AbstractBeginNode newBegin = new BeginNode();
425                graph.addAfterFixed(begin, graph.add(newBegin));
426                begin.replaceAtUsages(newBegin);
427                graph.removeFixed(begin);
428            }
429        } else {
430            if (unwindNode != null && unwindNode.isAlive()) {
431                DeoptimizeNode deoptimizeNode = graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateRecompile, DeoptimizationReason.NotCompiledExceptionHandler));
432                unwindNode.replaceAndDelete(deoptimizeNode);
433            }
434        }
435
436        ValueNode returnValue;
437        if (!returnNodes.isEmpty()) {
438            FixedNode n = invoke.next();
439            invoke.setNext(null);
440            if (returnNodes.size() == 1) {
441                ReturnNode returnNode = returnNodes.get(0);
442                returnValue = returnNode.result();
443                invokeNode.replaceAtUsages(returnValue);
444                returnNode.replaceAndDelete(n);
445            } else {
446                AbstractMergeNode merge = graph.add(new MergeNode());
447                merge.setStateAfter(stateAfter);
448                returnValue = mergeReturns(merge, returnNodes, canonicalizedNodes);
449                invokeNode.replaceAtUsages(returnValue);
450                merge.setNext(n);
451            }
452        } else {
453            returnValue = null;
454            invokeNode.replaceAtUsages(null);
455            GraphUtil.killCFG(invoke.next());
456        }
457
458        // Copy assumptions from inlinee to caller
459        Assumptions assumptions = graph.getAssumptions();
460        if (assumptions != null) {
461            if (inlinedAssumptions != null) {
462                assumptions.record(inlinedAssumptions);
463            }
464        } else {
465            assert inlinedAssumptions == null : "cannot inline graph which makes assumptions into a graph that doesn't";
466        }
467
468        // Copy inlined methods from inlinee to caller
469        graph.updateMethods(inlineGraph);
470
471        // Update the set of accessed fields
472        graph.updateFields(inlineGraph);
473
474        if (inlineGraph.hasUnsafeAccess()) {
475            graph.markUnsafeAccess();
476        }
477        assert inlineGraph.getSpeculationLog() == null : "Only the root graph should have a speculation log";
478
479        return returnValue;
480    }
481
482    private static String formatGraph(StructuredGraph graph) {
483        if (graph.method() == null) {
484            return graph.name;
485        }
486        return graph.method().format("%H.%n(%p)");
487    }
488
489    @SuppressWarnings("try")
490    private static void updateSourcePositions(Invoke invoke, StructuredGraph inlineGraph, Map<Node, Node> duplicates) {
491        if (inlineGraph.mayHaveNodeSourcePosition() && invoke.stateAfter() != null) {
492            if (invoke.asNode().getNodeSourcePosition() == null) {
493                // Temporarily ignore the assert below.
494                return;
495            }
496
497            JavaConstant constantReceiver = invoke.getInvokeKind().hasReceiver() ? invoke.getReceiver().asJavaConstant() : null;
498            NodeSourcePosition invokePos = invoke.asNode().getNodeSourcePosition();
499            assert invokePos != null : "missing source information";
500
501            Map<NodeSourcePosition, NodeSourcePosition> posMap = new HashMap<>();
502            for (Entry<Node, Node> entry : duplicates.entrySet()) {
503                NodeSourcePosition pos = entry.getKey().getNodeSourcePosition();
504                if (pos != null) {
505                    NodeSourcePosition callerPos = pos.addCaller(constantReceiver, invokePos);
506                    posMap.putIfAbsent(callerPos, callerPos);
507                    entry.getValue().setNodeSourcePosition(posMap.get(callerPos));
508                }
509            }
510        }
511    }
512
513    public static void processMonitorId(FrameState stateAfter, MonitorIdNode monitorIdNode) {
514        if (stateAfter != null) {
515            int callerLockDepth = stateAfter.nestedLockDepth();
516            monitorIdNode.setLockDepth(monitorIdNode.getLockDepth() + callerLockDepth);
517        }
518    }
519
520    protected static void processFrameStates(Invoke invoke, StructuredGraph inlineGraph, Map<Node, Node> duplicates, FrameState stateAtExceptionEdge, boolean alwaysDuplicateStateAfter) {
521        FrameState stateAtReturn = invoke.stateAfter();
522        FrameState outerFrameState = null;
523        JavaKind invokeReturnKind = invoke.asNode().getStackKind();
524        for (FrameState original : inlineGraph.getNodes(FrameState.TYPE)) {
525            FrameState frameState = (FrameState) duplicates.get(original);
526            if (frameState != null && frameState.isAlive()) {
527                if (outerFrameState == null) {
528                    outerFrameState = stateAtReturn.duplicateModifiedDuringCall(invoke.bci(), invokeReturnKind);
529                }
530                processFrameState(frameState, invoke, inlineGraph.method(), stateAtExceptionEdge, outerFrameState, alwaysDuplicateStateAfter, invoke.callTarget().targetMethod(),
531                                invoke.callTarget().arguments());
532            }
533        }
534    }
535
536    public static FrameState processFrameState(FrameState frameState, Invoke invoke, ResolvedJavaMethod inlinedMethod, FrameState stateAtExceptionEdge, FrameState outerFrameState,
537                    boolean alwaysDuplicateStateAfter, ResolvedJavaMethod invokeTargetMethod, List<ValueNode> invokeArgsList) {
538
539        assert outerFrameState == null || !outerFrameState.isDeleted() : outerFrameState;
540        FrameState stateAtReturn = invoke.stateAfter();
541        JavaKind invokeReturnKind = invoke.asNode().getStackKind();
542
543        if (frameState.bci == BytecodeFrame.AFTER_BCI) {
544            FrameState stateAfterReturn = stateAtReturn;
545            if (frameState.getCode() == null) {
546                // This is a frame state for a side effect within an intrinsic
547                // that was parsed for post-parse intrinsification
548                for (Node usage : frameState.usages()) {
549                    if (usage instanceof ForeignCallNode) {
550                        // A foreign call inside an intrinsic needs to have
551                        // the BCI of the invoke being intrinsified
552                        ForeignCallNode foreign = (ForeignCallNode) usage;
553                        foreign.setBci(invoke.bci());
554                    }
555                }
556            }
557
558            // pop return kind from invoke's stateAfter and replace with this frameState's return
559            // value (top of stack)
560            if (frameState.stackSize() > 0 && (alwaysDuplicateStateAfter || stateAfterReturn.stackAt(0) != frameState.stackAt(0))) {
561                stateAfterReturn = stateAtReturn.duplicateModified(invokeReturnKind, invokeReturnKind, frameState.stackAt(0));
562            }
563
564            // Return value does no longer need to be limited by the monitor exit.
565            for (MonitorExitNode n : frameState.usages().filter(MonitorExitNode.class)) {
566                n.clearEscapedReturnValue();
567            }
568
569            frameState.replaceAndDelete(stateAfterReturn);
570            return stateAfterReturn;
571        } else if (stateAtExceptionEdge != null && isStateAfterException(frameState)) {
572            // pop exception object from invoke's stateAfter and replace with this frameState's
573            // exception object (top of stack)
574            FrameState stateAfterException = stateAtExceptionEdge;
575            if (frameState.stackSize() > 0 && stateAtExceptionEdge.stackAt(0) != frameState.stackAt(0)) {
576                stateAfterException = stateAtExceptionEdge.duplicateModified(JavaKind.Object, JavaKind.Object, frameState.stackAt(0));
577            }
578            frameState.replaceAndDelete(stateAfterException);
579            return stateAfterException;
580        } else if (frameState.bci == BytecodeFrame.UNWIND_BCI || frameState.bci == BytecodeFrame.AFTER_EXCEPTION_BCI) {
581            return handleMissingAfterExceptionFrameState(frameState);
582        } else if (frameState.bci == BytecodeFrame.BEFORE_BCI) {
583            // This is an intrinsic. Deoptimizing within an intrinsic
584            // must re-execute the intrinsified invocation
585            assert frameState.outerFrameState() == null;
586            ValueNode[] invokeArgs = invokeArgsList.isEmpty() ? NO_ARGS : invokeArgsList.toArray(new ValueNode[invokeArgsList.size()]);
587            FrameState stateBeforeCall = stateAtReturn.duplicateModifiedBeforeCall(invoke.bci(), invokeReturnKind, invokeTargetMethod.getSignature().toParameterKinds(!invokeTargetMethod.isStatic()),
588                            invokeArgs);
589            frameState.replaceAndDelete(stateBeforeCall);
590            return stateBeforeCall;
591        } else {
592            // only handle the outermost frame states
593            if (frameState.outerFrameState() == null) {
594                assert checkInlineeFrameState(invoke, inlinedMethod, frameState);
595                frameState.setOuterFrameState(outerFrameState);
596            }
597            return frameState;
598        }
599    }
600
601    static boolean checkInlineeFrameState(Invoke invoke, ResolvedJavaMethod inlinedMethod, FrameState frameState) {
602        assert frameState.bci != BytecodeFrame.AFTER_EXCEPTION_BCI : frameState;
603        assert frameState.bci != BytecodeFrame.BEFORE_BCI : frameState;
604        assert frameState.bci != BytecodeFrame.UNKNOWN_BCI : frameState;
605        assert frameState.bci != BytecodeFrame.UNWIND_BCI : frameState;
606        if (frameState.bci != BytecodeFrame.INVALID_FRAMESTATE_BCI) {
607            ResolvedJavaMethod method = frameState.getMethod();
608            if (method.equals(inlinedMethod)) {
609                // Normal inlining expects all outermost inlinee frame states to
610                // denote the inlinee method
611            } else if (method.equals(invoke.callTarget().targetMethod())) {
612                // This occurs when an intrinsic calls back to the original
613                // method to handle a slow path. During parsing of such a
614                // partial intrinsic, these calls are given frame states
615                // that exclude the outer frame state denoting a position
616                // in the intrinsic code.
617                assert inlinedMethod.getAnnotation(
618                                MethodSubstitution.class) != null : "expected an intrinsic when inlinee frame state matches method of call target but does not match the method of the inlinee graph: " +
619                                                frameState;
620            } else if (method.getName().equals(inlinedMethod.getName())) {
621                // This can happen for method substitutions.
622            } else {
623                throw new AssertionError(String.format("inlinedMethod=%s frameState.method=%s frameState=%s invoke.method=%s", inlinedMethod, method, frameState,
624                                invoke.callTarget().targetMethod()));
625            }
626        }
627        return true;
628    }
629
630    private static final ValueNode[] NO_ARGS = {};
631
632    private static boolean isStateAfterException(FrameState frameState) {
633        return frameState.bci == BytecodeFrame.AFTER_EXCEPTION_BCI || (frameState.bci == BytecodeFrame.UNWIND_BCI && !frameState.getMethod().isSynchronized());
634    }
635
636    public static FrameState handleMissingAfterExceptionFrameState(FrameState nonReplaceableFrameState) {
637        Graph graph = nonReplaceableFrameState.graph();
638        NodeWorkList workList = graph.createNodeWorkList();
639        workList.add(nonReplaceableFrameState);
640        for (Node node : workList) {
641            FrameState fs = (FrameState) node;
642            for (Node usage : fs.usages().snapshot()) {
643                if (!usage.isAlive()) {
644                    continue;
645                }
646                if (usage instanceof FrameState) {
647                    workList.add(usage);
648                } else {
649                    StateSplit stateSplit = (StateSplit) usage;
650                    FixedNode fixedStateSplit = stateSplit.asNode();
651                    if (fixedStateSplit instanceof AbstractMergeNode) {
652                        AbstractMergeNode merge = (AbstractMergeNode) fixedStateSplit;
653                        while (merge.isAlive()) {
654                            AbstractEndNode end = merge.forwardEnds().first();
655                            DeoptimizeNode deoptimizeNode = graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateRecompile, DeoptimizationReason.NotCompiledExceptionHandler));
656                            end.replaceAtPredecessor(deoptimizeNode);
657                            GraphUtil.killCFG(end);
658                        }
659                    } else {
660                        FixedNode deoptimizeNode = graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateRecompile, DeoptimizationReason.NotCompiledExceptionHandler));
661                        if (fixedStateSplit instanceof AbstractBeginNode) {
662                            deoptimizeNode = BeginNode.begin(deoptimizeNode);
663                        }
664                        fixedStateSplit.replaceAtPredecessor(deoptimizeNode);
665                        GraphUtil.killCFG(fixedStateSplit);
666                    }
667                }
668            }
669        }
670        return nonReplaceableFrameState;
671    }
672
673    public static ValueNode mergeReturns(AbstractMergeNode merge, List<? extends ReturnNode> returnNodes, List<Node> canonicalizedNodes) {
674        return mergeValueProducers(merge, returnNodes, canonicalizedNodes, returnNode -> returnNode.result());
675    }
676
677    public static <T extends ControlSinkNode> ValueNode mergeValueProducers(AbstractMergeNode merge, List<? extends T> valueProducers, List<Node> canonicalizedNodes,
678                    Function<T, ValueNode> valueFunction) {
679        ValueNode singleResult = null;
680        PhiNode phiResult = null;
681        for (T valueProducer : valueProducers) {
682            ValueNode result = valueFunction.apply(valueProducer);
683            if (result != null) {
684                if (phiResult == null && (singleResult == null || singleResult == result)) {
685                    /* Only one result value, so no need yet for a phi node. */
686                    singleResult = result;
687                } else if (phiResult == null) {
688                    /* Found a second result value, so create phi node. */
689                    phiResult = merge.graph().addWithoutUnique(new ValuePhiNode(result.stamp().unrestricted(), merge));
690                    if (canonicalizedNodes != null) {
691                        canonicalizedNodes.add(phiResult);
692                    }
693                    for (int i = 0; i < merge.forwardEndCount(); i++) {
694                        phiResult.addInput(singleResult);
695                    }
696                    phiResult.addInput(result);
697
698                } else {
699                    /* Multiple return values, just add to existing phi node. */
700                    phiResult.addInput(result);
701                }
702            }
703
704            // create and wire up a new EndNode
705            EndNode endNode = merge.graph().add(new EndNode());
706            merge.addForwardEnd(endNode);
707            valueProducer.replaceAndDelete(endNode);
708        }
709
710        if (phiResult != null) {
711            assert phiResult.verify();
712            phiResult.inferStamp();
713            return phiResult;
714        } else {
715            return singleResult;
716        }
717    }
718
719    private static boolean checkContainsOnlyInvalidOrAfterFrameState(Map<Node, Node> duplicates) {
720        for (Node node : duplicates.values()) {
721            if (node instanceof FrameState) {
722                FrameState frameState = (FrameState) node;
723                assert frameState.bci == BytecodeFrame.AFTER_BCI || frameState.bci == BytecodeFrame.INVALID_FRAMESTATE_BCI : node.toString(Verbosity.Debugger);
724            }
725        }
726        return true;
727    }
728
729    /**
730     * Gets the receiver for an invoke, adding a guard if necessary to ensure it is non-null, and
731     * ensuring that the resulting type is compatible with the method being invoked.
732     */
733    public static ValueNode nonNullReceiver(Invoke invoke) {
734        MethodCallTargetNode callTarget = (MethodCallTargetNode) invoke.callTarget();
735        assert !callTarget.isStatic() : callTarget.targetMethod();
736        StructuredGraph graph = callTarget.graph();
737        ValueNode firstParam = callTarget.arguments().get(0);
738        if (firstParam.getStackKind() == JavaKind.Object) {
739            Stamp paramStamp = firstParam.stamp();
740            Stamp stamp = paramStamp.join(StampFactory.objectNonNull(TypeReference.create(graph.getAssumptions(), callTarget.targetMethod().getDeclaringClass())));
741            if (!StampTool.isPointerNonNull(firstParam)) {
742                LogicNode condition = graph.unique(IsNullNode.create(firstParam));
743                FixedGuardNode fixedGuard = graph.add(new FixedGuardNode(condition, NullCheckException, InvalidateReprofile, true));
744                PiNode nonNullReceiver = graph.unique(new PiNode(firstParam, stamp, fixedGuard));
745                graph.addBeforeFixed(invoke.asNode(), fixedGuard);
746                callTarget.replaceFirstInput(firstParam, nonNullReceiver);
747                return nonNullReceiver;
748            }
749            if (!stamp.equals(paramStamp)) {
750                PiNode cast = graph.unique(new PiNode(firstParam, stamp));
751                callTarget.replaceFirstInput(firstParam, cast);
752                return cast;
753            }
754        }
755        return firstParam;
756    }
757
758    public static boolean canIntrinsify(Replacements replacements, ResolvedJavaMethod target, int invokeBci) {
759        return replacements.hasSubstitution(target, invokeBci);
760    }
761
762    public static StructuredGraph getIntrinsicGraph(Replacements replacements, ResolvedJavaMethod target, int invokeBci) {
763        return replacements.getSubstitution(target, invokeBci);
764    }
765
766    public static FixedWithNextNode inlineMacroNode(Invoke invoke, ResolvedJavaMethod concrete, Class<? extends FixedWithNextNode> macroNodeClass) throws GraalError {
767        StructuredGraph graph = invoke.asNode().graph();
768        if (!concrete.equals(((MethodCallTargetNode) invoke.callTarget()).targetMethod())) {
769            assert ((MethodCallTargetNode) invoke.callTarget()).invokeKind().hasReceiver();
770            InliningUtil.replaceInvokeCallTarget(invoke, graph, InvokeKind.Special, concrete);
771        }
772
773        FixedWithNextNode macroNode = createMacroNodeInstance(macroNodeClass, invoke);
774
775        CallTargetNode callTarget = invoke.callTarget();
776        if (invoke instanceof InvokeNode) {
777            graph.replaceFixedWithFixed((InvokeNode) invoke, graph.add(macroNode));
778        } else {
779            InvokeWithExceptionNode invokeWithException = (InvokeWithExceptionNode) invoke;
780            invokeWithException.killExceptionEdge();
781            graph.replaceSplitWithFixed(invokeWithException, graph.add(macroNode), invokeWithException.next());
782        }
783        GraphUtil.killWithUnusedFloatingInputs(callTarget);
784        return macroNode;
785    }
786
787    private static FixedWithNextNode createMacroNodeInstance(Class<? extends FixedWithNextNode> macroNodeClass, Invoke invoke) throws GraalError {
788        try {
789            Constructor<?> cons = macroNodeClass.getDeclaredConstructor(Invoke.class);
790            return (FixedWithNextNode) cons.newInstance(invoke);
791        } catch (ReflectiveOperationException | IllegalArgumentException | SecurityException e) {
792            throw new GraalGraphError(e).addContext(invoke.asNode()).addContext("macroSubstitution", macroNodeClass);
793        }
794    }
795
796    /**
797     * This method exclude InstrumentationNode from inlining heuristics.
798     */
799    public static int getNodeCount(StructuredGraph graph) {
800        if (UseGraalInstrumentation.getValue()) {
801            return graph.getNodeCount() - graph.getNodes().filter(InstrumentationNode.class).count();
802        } else {
803            return graph.getNodeCount();
804        }
805    }
806
807    /**
808     * This method detach the instrumentation attached to the given Invoke. It is called when the
809     * given Invoke is inlined.
810     */
811    public static void detachInstrumentation(Invoke invoke) {
812        FixedNode invokeNode = invoke.asNode();
813        for (InstrumentationNode instrumentation : invokeNode.usages().filter(InstrumentationNode.class).snapshot()) {
814            if (instrumentation.getTarget() == invoke) {
815                instrumentation.replaceFirstInput(instrumentation.getTarget(), null);
816            }
817        }
818    }
819
820}
821