import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
/**
 * Finds all {@link DirectCallNode} instances calling a certain original {@link CallTarget} in a
 * given {@link RootNode}.
 */
@TruffleBoundary
protected static final Set<DirectCallNode> findCallsTo(RootNode root, OptimizedCallTarget originalCallTarget) {
    final Set<DirectCallNode> allCallNodes = new HashSet<>();
    root.accept(new NodeVisitor() {
        @Override
        public boolean visit(Node node) {
            if (node instanceof DirectCallNode) {
                DirectCallNode callNode = (DirectCallNode) node;
                if (callNode.getCallTarget() == originalCallTarget || callNode.getClonedCallTarget() == originalCallTarget) {
                    allCallNodes.add(callNode);
                }
            }
            return true;
        }
    });
    return allCallNodes;
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
@Override
public void notifyCompilationSuccess(OptimizedCallTarget target, TruffleInlining inliningDecision, StructuredGraph graph, CompilationResult result,
                Map<OptimizedCallTarget, Object> compilationMap) {
    super.notifyCompilationSuccess(target, inliningDecision, graph, result, compilationMap);

    for (Node node : target.nodeIterable(inliningDecision)) {
        if (node != null && (node.getCost() == NodeCost.MEGAMORPHIC || node.getCost() == NodeCost.POLYMORPHIC)) {
            NodeCost cost = node.getCost();
            Map<String, Object> props = new LinkedHashMap<>();
            props.put("simpleName", node.getClass().getSimpleName());
            props.put("subtree", "\n" + NodeUtil.printCompactTreeToString(node));
            String msg = cost == NodeCost.MEGAMORPHIC ? "megamorphic" : "polymorphic";
            log(0, msg, node.toString(), props);
        }
    }
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
@Override
public boolean visit(Node node) {
    if (node instanceof OptimizedDirectCallNode) {
        OptimizedDirectCallNode callNode = (OptimizedDirectCallNode) node;
        TruffleInlining inlining = stack.get(stack.size() - 1);
        if (inlining != null) {
            TruffleInliningDecision childInlining = inlining.findByCall(callNode);
            if (childInlining != null) {
                stack.add(childInlining);
                continueTraverse = visitNode(node);
                if (continueTraverse && childInlining.isInline()) {
                    childInlining.getTarget().getRootNode().accept(this);
                }
                stack.remove(stack.size() - 1);
            }
        }
        return continueTraverse;
    } else {
        continueTraverse = visitNode(node);
        return continueTraverse;
    }
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
@Override
public boolean nodeReplaced(Node oldNode, Node newNode, CharSequence reason) {
    CompilerAsserts.neverPartOfCompilation();
    if (isValid()) {
        invalidate(newNode, reason);
    }
    /* Notify compiled method that have inlined this call target that the tree changed. */
    invalidateNodeRewritingAssumption();

    OptimizedCompilationProfile profile = this.compilationProfile;
    if (profile != null) {
        profile.reportNodeReplaced();
        if (cancelInstalledTask(newNode, reason)) {
            profile.reportInvalidated();
        }
    }
    return false;
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
@Override
public void onLoopCount(Node source, int count) {
    Node node = source;
    Node parentNode = source != null ? source.getParent() : null;
    while (node != null) {
        if (node instanceof OptimizedOSRLoopNode) {
            ((OptimizedOSRLoopNode) node).reportChildLoopCount(count);
        }
        parentNode = node;
        node = node.getParent();
    }
    if (parentNode != null && parentNode instanceof RootNode) {
        CallTarget target = ((RootNode) parentNode).getCallTarget();
        if (target instanceof OptimizedCallTarget) {
            ((OptimizedCallTarget) target).onLoopCount(count);
        }
    }
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
public static long doLoop(final DirectCallNode value,
    final Node loopNode, final long receiver, final long limit, final long step,
    final SBlock block) {
  try {
    if (receiver <= limit) {
      value.call(new Object[] {block, receiver});
    }
    for (long i = receiver + step; i <= limit; i += step) {
      value.call(new Object[] {block, i});
      ObjectTransitionSafepoint.INSTANCE.checkAndPerformSafepoint();
    }
  } finally {
    if (CompilerDirectives.inInterpreter()) {
      long loopCount = limit - receiver;
      if (loopCount > 0) {
        SomLoop.reportLoopCount(loopCount, loopNode);
      }
    }
  }
  return receiver;
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
public ExecutionEventNode create(final EventContext ec) {
            final PrintStream out = new PrintStream(env.out());

            return new ExecutionEventNode() {
                /*@Override
                protected void onReturnValue(VirtualFrame frame, Object result) {
                    out.println("return" + this);
                }*/

                @Override
                protected void onEnter(VirtualFrame frame) {
                    Node node = ec.getInstrumentedNode();
                    out.println("node: " + node);
                    out.println("-> " + node.getEncapsulatingSourceSection().toString());
//                    if (node instanceof InvokeNode) {
//                        InvokeNode invokeNode = (InvokeNode) node;
//                        out.println("invoke: " + invokeNode.getForm());
//                    } else if (node instanceof EvalFactory.EvalNodeGen) {
//                        EvalFactory.EvalNodeGen evalNode = (EvalFactory.EvalNodeGen) node;
//                        out.println("eval: " + evalNode);
//                    } else if (node instanceof RootNode) {
//                        RootNode rootNode = (RootNode) node;
//                        out.println("root: " + rootNode);
//                    }
                }

            };
        }
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
private boolean evaluateCondition(VirtualFrame frame) {
    Object ret = conditionNode.executeGeneric(frame);
    if (ret == Symbol.TRUE) {
        return true;
    } else if (ret == Symbol.FALSE) {
        return false;
    } else {
        throw new UnsupportedSpecializationException(this, new Node[]{conditionNode}, ret);
    }
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
private static String formatStackFrame(FrameInstance frameInstance, CallTarget target) {
    StringBuilder builder = new StringBuilder();
    if (target instanceof RootCallTarget) {
        RootNode root = ((RootCallTarget) target).getRootNode();
        String name = root.getName();
        if (name == null) {
            builder.append("unnamed-root");
        } else {
            builder.append(name);
        }
        Node callNode = frameInstance.getCallNode();
        SourceSection sourceSection = null;
        if (callNode != null) {
            sourceSection = callNode.getEncapsulatingSourceSection();
        }
        if (sourceSection == null) {
            sourceSection = root.getSourceSection();
        }

        if (sourceSection == null || sourceSection.getSource() == null) {
            builder.append("(Unknown)");
        } else {
            builder.append("(").append(formatPath(sourceSection)).append(":").append(sourceSection.getStartLine()).append(")");
        }

        if (target instanceof OptimizedCallTarget) {
            OptimizedCallTarget callTarget = ((OptimizedCallTarget) target);
            if (callTarget.isValid()) {
                builder.append(" <opt>");
            }
            if (callTarget.getSourceCallTarget() != null) {
                builder.append(" <split-" + Integer.toHexString(callTarget.hashCode()) + ">");
            }
        }

    } else {
        builder.append(target.toString());
    }
    return builder.toString();
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
InlineTestRootNode(int size, String name) {
    super(null);

    children = new Node[size];
    for (int i = 0; i < children.length; i++) {
        children[i] = new InlineTestRootNode(0, "");
    }
    this.name = name;
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
@Override
public Object execute(VirtualFrame frame) {

    int maxRecursionDepth = (int) frame.getArguments()[0];
    if (maxRecursionDepth < 100) {
        for (Node child : children) {
            if (child instanceof OptimizedDirectCallNode) {
                OptimizedDirectCallNode callNode = (OptimizedDirectCallNode) child;
                frame.getArguments()[0] = maxRecursionDepth + 1;
                callNode.call(frame.getArguments());
            }
        }
    }
    return null;
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
private synchronized Object executeAndSpecialize(Object arg0Value) {
    if (arg0Value instanceof AbstractType) {
        AbstractType arg0Value0 = (AbstractType) arg0Value;
        CachedData s1 = cached;
        AbstractType cachedOperand = (arg0Value0);
        s1 = new CachedData(cached, cachedOperand);
        this.cached = s1;
        return s1.cachedOperand.someMethod();
    }
    CompilerDirectives.transferToInterpreterAndInvalidate();
    throw new UnsupportedSpecializationException(this, new Node[]{});
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
private static OptimizedCallTarget findOSRTarget(Node loopNode) {
    if (loopNode instanceof OptimizedOSRLoopNode) {
        return ((OptimizedOSRLoopNode) loopNode).getCompiledOSRLoop();
    }

    for (Node child : loopNode.getChildren()) {
        OptimizedCallTarget target = findOSRTarget(child);
        if (target != null) {
            return target;
        }
    }

    return null;
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
private OptimizedCallTarget compileImpl(VirtualFrame frame) {
    RootNode root = getRootNode();
    Node parent = getParent();
    if (speculationLog == null) {
        speculationLog = GraalTruffleRuntime.getRuntime().createSpeculationLog();
    }
    OptimizedCallTarget osrTarget = (OptimizedCallTarget) GraalTruffleRuntime.getRuntime().createCallTarget(createRootNodeImpl(root, frame.getClass()));
    osrTarget.setSpeculationLog(speculationLog);
    // let the old parent re-adopt the children
    parent.adoptChildren();
    osrTarget.compile();
    return osrTarget;
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
private static Collection<Class<?>> nodeClasses(StructuredGraph graph) {
    Collection<Class<?>> classes = new ArrayList<>();
    for (org.graalvm.compiler.graph.Node node : graph.getNodes()) {
        classes.add(node.getClass());
    }
    return classes;
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
private boolean visitNode(List<TruffleInlining> stack, Node node) {
    if (node == null) {
        return true;
    }

    NodeCost cost = node.getCost();
    if (cost.isTrivial()) {
        nodeCountTrivial++;
    } else {
        nodeCountNonTrivial++;
        if (cost == NodeCost.MONOMORPHIC) {
            nodeCountMonomorphic++;
        } else if (cost == NodeCost.POLYMORPHIC) {
            nodeCountPolymorphic++;
        } else if (cost == NodeCost.MEGAMORPHIC) {
            nodeCountMegamorphic++;
        }
    }

    if (node instanceof DirectCallNode) {
        TruffleInliningDecision decision = CallTreeNodeVisitor.getCurrentInliningDecision(stack);
        if (decision != null && decision.getProfile().getCallNode() == node && decision.isInline()) {
            callCountDirectInlined++;
        } else {
            callCountDirectDispatched++;
        }
        if (decision != null && decision.getProfile().getCallNode().isCallTargetCloned()) {
            callCountDirectCloned++;
        } else {
            callCountDirectNotCloned++;
        }
    } else if (node instanceof IndirectCallNode) {
        callCountIndirect++;
    } else if (node instanceof LoopNode) {
        loopCount++;
    }

    return true;
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
private static List<OptimizedDirectCallNode> getCallNodes(OptimizedCallTarget target) {
    final List<OptimizedDirectCallNode> callNodes = new ArrayList<>();
    target.getRootNode().accept(new NodeVisitor() {
        @Override
        public boolean visit(Node node) {
            if (node instanceof OptimizedDirectCallNode) {
                callNodes.add((OptimizedDirectCallNode) node);
            }
            return true;
        }
    });
    return callNodes;
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
static int getNodeDepth(List<TruffleInlining> decisionStack, Node node) {
    int depth = calculateNodeDepth(node);
    if (decisionStack != null) {
        for (int i = decisionStack.size() - 1; i > 0; i--) {
            TruffleInliningDecision decision = (TruffleInliningDecision) decisionStack.get(i);
            depth += calculateNodeDepth(decision.getProfile().getCallNode());
        }
    }
    return depth;
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
static int calculateNodeDepth(Node node) {
    int depth = 0;
    Node traverseNode = node;
    while (traverseNode != null) {
        depth++;
        traverseNode = traverseNode.getParent();
    }
    return depth;
}
 

import com.oracle.truffle.api.nodes.Node; //导入依赖的package包/类
private boolean visitNode(Node node) {
    if (visitor instanceof CallTreeNodeVisitor) {
        return ((CallTreeNodeVisitor) visitor).visit(stack, node);
    } else {
        return visitor.visit(node);
    }
}