import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Specialization(guards = {"function.getArity() < arguments.length"})
public Object doOver(VirtualFrame frame, Function function, Object[] arguments,
                     @Cached("createDispatchNode()") DispatchNode dispatchNode) {
    int argIndex = 0;

    while (function.getArity() < arguments.length-argIndex) {
        Object[] argumentValues = Arrays.copyOfRange(arguments, argIndex, argIndex+function.getArity());

        argIndex += function.getArity();
        function = (Function) call(dispatchNode, frame, function, function.packArguments(argumentValues), false);
    }

    Object[] remainingArguments = Arrays.copyOfRange(arguments, argIndex, arguments.length);

    if (function.getArity() > remainingArguments.length) {
        return function.curry(remainingArguments);
    } else {
        return call(dispatchNode, frame, function, function.packArguments(remainingArguments));
    }
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Override
public Object executeGeneric(VirtualFrame frame) {
  Object parent = this.targetNode.executeGeneric(frame);

  if (this.type instanceof MethodType) {
    MethodType methodType = (MethodType)this.type;
    return new Method(parent, methodType.getCallTarget(), methodType.getName());
  }

  Class<?> parentClass = parent.getClass();
  try {
    Field field = parentClass.getField(this.propertyName);
    return field.get(parent);
  } catch (NoSuchFieldException | IllegalAccessException error) {
    throw new RuntimeException(error);
  }
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Specialization(guards = {"needsBindings()"})
public Bindings createBindings(
  VirtualFrame frame,
  @Cached("createGetBindingsNode()") GetBindingsNode getBindingsNode,
  @Cached(value = "createFetchers()", dimensions = 1) Fetcher[] fetchers
) {
  Bindings ownBindings = getBindingsNode.executeGetBindings(frame);
  Bindings bindings = new Bindings();
  if (fetchers.length > 0) {
    MaterializedFrame materializedFrame = frame.materialize();
    for (Fetcher fetcher : fetchers) {
      String name = fetcher.getName();
      Binding binding = fetcher.fetch(materializedFrame, ownBindings);
      bindings.add(name, binding);
    }
  }
  return bindings;
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Test
public void testCompileOnly4() {
    // OSR should not trigger for compile-only includes
    try (TruffleOptionsOverrideScope scope = TruffleCompilerOptions.overrideOptions(TruffleCompileOnly, "foobar")) {
        final OSRRepeatingNode repeating = new OSRRepeatingNode(TruffleCompilerOptions.getValue(TruffleOSRCompilationThreshold));
        final LoopNode loop = runtime.createLoopNode(repeating);
        OptimizedCallTarget target = (OptimizedCallTarget) runtime.createCallTarget(new NamedRootNode("foobar") {

            @Child LoopNode loopChild = loop;

            @Override
            public Object execute(VirtualFrame frame) {
                loopChild.executeLoop(frame);
                return super.execute(frame);
            }

        });
        target.call();
        OptimizedCallTarget osrTarget = findOSRTarget(loop);
        if (osrTarget != null) {
            assertNotCompiled(osrTarget);
        }
    }
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Test
public void testCompileOnly5() {
    // OSR should trigger if compile-only with excludes
    try (TruffleOptionsOverrideScope scope = TruffleCompilerOptions.overrideOptions(TruffleCompileOnly, "~foobar")) {
        final OSRRepeatingNode repeating = new OSRRepeatingNode(TruffleCompilerOptions.getValue(TruffleOSRCompilationThreshold));
        final LoopNode loop = runtime.createLoopNode(repeating);
        OptimizedCallTarget target = (OptimizedCallTarget) runtime.createCallTarget(new NamedRootNode("foobar") {

            @Child LoopNode loopChild = loop;

            @Override
            public Object execute(VirtualFrame frame) {
                loopChild.executeLoop(frame);
                return super.execute(frame);
            }

        });
        target.call();
        OptimizedCallTarget osrTarget = findOSRTarget(loop);
        assertCompiled(osrTarget);
    }
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
private boolean compilingLoop(VirtualFrame frame) {
    int iterations = 0;
    try {
        do {
            OptimizedCallTarget target = compiledOSRLoop;
            if (target == null) {
                return false;
            }
            if (target.isValid()) {
                return directCallTarget(target, frame);
            }
            if (!target.isCompiling()) {
                invalidateOSRTarget(this, "OSR compilation failed or cancelled");
                return false;
            }

            iterations++;

        } while (repeatableNode.executeRepeating(frame));
        return true;
    } finally {
        baseLoopCount += iterations;
        reportParentLoopCount(iterations);
    }
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Override
public void executeLoop(VirtualFrame frame) {
    if (CompilerDirectives.inInterpreter()) {
        try {
            boolean done = false;
            while (!done) {
                if (compiledOSRLoop == null) {
                    done = profilingLoop(frame);
                } else {
                    done = compilingLoop(frame);
                }
            }
        } finally {
            baseLoopCount = 0;
        }
    } else {
        while (repeatableNode.executeRepeating(frame)) {
            if (CompilerDirectives.inInterpreter()) {
                // compiled method got invalidated. We might need OSR again.
                executeLoop(frame);
                return;
            }
        }
    }
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
private boolean profilingLoop(VirtualFrame frame) {
    int iterations = 0;
    int threshold = getThreshold();
    try {
        while (repeatableNode.executeRepeating(frame)) {
            // the baseLoopCount might be updated from a child loop during an iteration.
            if (++iterations + baseLoopCount > threshold) {
                compileLoop(frame);
                return false;
            }
        }
        return true;
    } finally {
        baseLoopCount += iterations;
        reportParentLoopCount(iterations);
    }
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Test
public void testControlFlow3() {
    testEnsureVirtualized(true, new TestNode() {
        @Override
        public void executeVoid(VirtualFrame frame) {
            Integer object = new Integer(intField);
            GraalDirectives.ensureVirtualized(object);
            if (booleanField) {
                field = 1;
            } else {
                field = 2;
            }
            field = object; // assert here
        }
    });
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Test
public void testIndirect2() {
    testEnsureVirtualized(false, new TestNode() {
        @Override
        public void executeVoid(VirtualFrame frame) {
            Integer object = new Integer(intField);
            TestClass t = new TestClass();
            t.a = object;
            GraalDirectives.ensureVirtualized(t);

            if (booleanField) {
                field = object;
            } else {
                field = 2;
            }
        }
    });
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Override
protected OSRRootNode createRootNode(FrameDescriptor rootFrameDescriptor, Class<? extends VirtualFrame> clazz) {
    if (readFrameSlots == null || writtenFrameSlots == null) {
        return super.createRootNode(rootFrameDescriptor, clazz);
    } else {
        FrameDescriptor frameDescriptor = rootFrameDescriptor == null ? new FrameDescriptor() : rootFrameDescriptor;
        if (previousRoot == null) {
            previousRoot = new VirtualizingOSRRootNode(this, frameDescriptor, clazz, readFrameSlots, writtenFrameSlots);
        } else {
            // we want to reuse speculations from a previous compilation so no rewrite loops
            // occur.
            previousRoot = new VirtualizingOSRRootNode(previousRoot, this, frameDescriptor, clazz);
        }
        return previousRoot;
    }
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Override
public Object execute(VirtualFrame frame) {
    entered = 1;
    for (;;) {
        try {
            if (terminate != 0) {
                throw BREAK_EX;
            } else {
                throw CONTINUE_EX;
            }
        } catch (RuntimeException e) {
            if (e == BREAK_EX) {
                break;
            } else if (e == CONTINUE_EX) {
                continue;
            }
            throw e;
        }
    }
    return RETURN_VALUE;
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Test
public void testCanBeClonedWithoutParent() {
    final RootNode rootNode = new RootNode(null) {
        @Override
        public Object execute(VirtualFrame frame) {
            return 42;
        }

        @Override
        public boolean isCloningAllowed() {
            return true;
        }
    };
    final CallTarget callTarget = Truffle.getRuntime().createCallTarget(rootNode);
    final DirectCallNode callNode = Truffle.getRuntime().createDirectCallNode(callTarget);

    assertTrue(callNode.isCallTargetCloningAllowed());
    assertTrue(callNode.cloneCallTarget());
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的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.frame.VirtualFrame; //导入依赖的package包/类
@Specialization(contains = {"readLong", "readBoolean"})
protected Object readObject(VirtualFrame frame) {
    if (!frame.isObject(getSlot())) {
        CompilerDirectives.transferToInterpreter();
        Object result = frame.getValue(getSlot());
        frame.setObject(getSlot(), result);
        return result;
    }

    return FrameUtil.getObjectSafe(frame, getSlot());
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Specialization(guards = "isLongOrIllegal(frame)")
protected long writeLong(VirtualFrame frame, long value) {
    getSlot().setKind(FrameSlotKind.Long);

    frame.setLong(getSlot(), value);
    return value;
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Specialization(guards = "isBooleanOrIllegal(frame)")
protected boolean writeBoolean(VirtualFrame frame, boolean value) {
    getSlot().setKind(FrameSlotKind.Boolean);

    frame.setBoolean(getSlot(), value);
    return value;
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Specialization(contains = {"writeLong", "writeBoolean"})
protected Object write(VirtualFrame frame, Object value) {
    getSlot().setKind(FrameSlotKind.Object);

    frame.setObject(getSlot(), value);
    return value;
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Specialization(contains = { "readLong", "readDouble", "readObject" })
protected Object read(VirtualFrame virtualFrame) {
    try {
        return this.readUpStack(Frame::getValue, virtualFrame);
    } catch (FrameSlotTypeException e) {
        // FrameSlotTypeException not thrown
    }
    return null;
}
 

import com.oracle.truffle.api.frame.VirtualFrame; //导入依赖的package包/类
@Override
public Object executeGeneric(VirtualFrame frame) {
    Object[] args = frame.getArguments();
    return args[index];

    // if (index < args.length) {
    //     return args[index];
    // } else {
    //     /* In the interpreter, record profiling information that the branch was used. */
    //     outOfBoundsTaken.enter();
    //     /* Use the default null value. */
    //     return SLNull.SINGLETON;
    // }
}