import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
public Context(Language language, TruffleLanguage.Env env) {
    this.language = language;
    this.globalFrame = Truffle.getRuntime().createMaterializedFrame(null);
    this.functions = new HashMap<>();

    set("*language*", "Java");
    set("*implementation*", "Truffle / " + Truffle.getRuntime().getName());
    set("*porters*", new String("Ragnar Dahlén".getBytes(), Charset.forName("ISO-8859-1")));
    set("*port*", "0.1");
    set("*stinput*", env.in());
    set("*stoutput*", env.out());
    set("*home-directory*", System.getProperty("user.dir"));

    for(NodeFactory nodeFactory : Builtins.NODE_FACTORIES) {
        installBuiltin(nodeFactory);
    }
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
public void installBuiltin(NodeFactory<? extends BuiltinNode> factory) {
    int argumentCount = factory.getExecutionSignature().size();

    ExpressionNode[] argumentNodes = new ExpressionNode[argumentCount];
    for (int i = 0; i < argumentCount; i++) {
        argumentNodes[i] = new ReadArgumentNode(i+1);
    }

    BuiltinNode builtinBodyNode = factory.createNode(argumentNodes, this);
    //builtinBodyNode.addRootTag();
    /* The name of the builtin function is specified via an annotation on the node class. */
    String name = lookupNodeInfo(builtinBodyNode.getClass()).shortName();
    //final SourceSection srcSection = BUILTIN_SOURCE.createUnavailableSection();
    //builtinBodyNode.setSourceSection(srcSection);

    RootNode rootNode = new RootNode(language, new FrameDescriptor(), builtinBodyNode, name);
    Function f = new Function(Truffle.getRuntime().createCallTarget(rootNode), argumentCount);
    f.setName(name);

    registerFunction(name, f);
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
private void addNodeFactories(List<? extends NodeFactory<? extends HBNode>> factories) {
  for (NodeFactory<? extends HBNode> factory : factories) {
    Class<?> nodeClass = factory.getClass().getAnnotation(GeneratedBy.class).value();
    BuiltinMethod methodAnnotation = this.getMethodAnnotation(nodeClass);
    BuiltinClass classAnnotation = this.getClassAnnotation(nodeClass);

    String methodName = methodAnnotation.value();
    String className = classAnnotation.value();
    MethodTargets methodTargets = this.getOrCreateMethodTargets(className);

    HBNode bodyNode = this.createNode(factory, methodAnnotation);

    HBBuiltinRootNode rootNode = new HBBuiltinRootNode(
      this.language,
      new FrameDescriptor(),
      bodyNode
    );
    CallTarget callTarget = Truffle.getRuntime().createCallTarget(rootNode);
    methodTargets.put(methodName, callTarget);
  }
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
@Override
protected CallTarget parse(ParsingRequest request) throws Exception {
  Source source = request.getSource();
  HBSourceRootNode program = ParserWrapper.parse(this, source);

  System.out.println(program.toString());

  // Bootstrap the builtin node targets and the builtin types in the
  // type-system.
  BuiltinNodes builtinNodes = BuiltinNodes.bootstrap(this);
  Index index = Index.bootstrap(builtinNodes);

  InferenceVisitor visitor = new InferenceVisitor(index);
  program.accept(visitor);

  return Truffle.getRuntime().createCallTarget(program);
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
/**
 * Finds all call targets available for the same original call target. This might be useful if a
 * {@link CallTarget} got duplicated due to splitting.
 */
@SuppressWarnings("deprecation")
@TruffleBoundary
protected static final Set<OptimizedCallTarget> findDuplicateCallTargets(OptimizedCallTarget originalCallTarget) {
    final Set<OptimizedCallTarget> allCallTargets = new HashSet<>();
    allCallTargets.add(originalCallTarget);
    for (RootCallTarget target : Truffle.getRuntime().getCallTargets()) {
        if (target instanceof OptimizedCallTarget) {
            OptimizedCallTarget oct = (OptimizedCallTarget) target;
            if (oct.getSourceCallTarget() == originalCallTarget) {
                allCallTargets.add(oct);
            }
        }
    }
    return allCallTargets;
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
@Test
public void twoIfsTest() {
    InstrumentPhase.Instrumentation instrumentation = ((GraalTruffleRuntime) Truffle.getRuntime()).getInstrumentation();
    FrameDescriptor descriptor = new FrameDescriptor();
    TwoIfsTestNode result = new TwoIfsTestNode(5, -1);
    RootTestNode rootNode = new RootTestNode(descriptor, "twoIfsRoot", result);
    OptimizedCallTarget target = compileHelper("twoIfsRoot", rootNode, new Object[0]);
    Assert.assertTrue(target.isValid());
    // We run this twice to make sure that it comes first in the sorted access list.
    target.call();
    target.call();
    String stackOutput1 = instrumentation.accessTableToList(getOptions()).get(0);
    Assert.assertTrue(stackOutput1.contains("org.graalvm.compiler.truffle.test.InstrumentBranchesPhaseTest$TwoIfsTestNode.execute(InstrumentBranchesPhaseTest.java"));
    Assert.assertTrue(stackOutput1.contains("[bci: 4]\n[1] state = ELSE(if=0#, else=2#)"));
    String stackOutput2 = instrumentation.accessTableToList(getOptions()).get(1);
    Assert.assertTrue(stackOutput2.contains("org.graalvm.compiler.truffle.test.InstrumentBranchesPhaseTest$TwoIfsTestNode.execute(InstrumentBranchesPhaseTest.java"));
    Assert.assertTrue(stackOutput2.contains("[bci: 18]\n[2] state = IF(if=2#, else=0#)"));
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的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.Truffle; //导入依赖的package包/类
@TruffleBoundary
private void checkStackTrace() {
    final OptimizedOSRLoopNode loop = (OptimizedOSRLoopNode) getParent();
    final OptimizedCallTarget compiledLoop = loop.getCompiledOSRLoop();

    Truffle.getRuntime().iterateFrames(new FrameInstanceVisitor<Void>() {
        @Override
        public Void visitFrame(FrameInstance frameInstance) {
            Assert.assertNotSame(compiledLoop, frameInstance.getCallTarget());
            return null;
        }
    });
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
public TruffleCompiler(Plugins plugins, Suites suites, LIRSuites lirSuites, Backend backend, SnippetReflectionProvider snippetReflection) {
    GraalTruffleRuntime graalTruffleRuntime = ((GraalTruffleRuntime) Truffle.getRuntime());
    this.compilationNotify = graalTruffleRuntime.getCompilationNotify();
    this.backend = backend;
    this.snippetReflection = snippetReflection;
    this.providers = backend.getProviders();
    this.suites = suites;
    this.lirSuites = lirSuites;

    ResolvedJavaType[] skippedExceptionTypes = getSkippedExceptionTypes(providers.getMetaAccess());

    boolean needSourcePositions = graalTruffleRuntime.enableInfopoints() || TruffleCompilerOptions.getValue(TruffleEnableInfopoints) ||
                    TruffleCompilerOptions.getValue(TruffleInstrumentBranches) || TruffleCompilerOptions.getValue(TruffleInstrumentBoundaries);
    GraphBuilderConfiguration baseConfig = GraphBuilderConfiguration.getDefault(new Plugins(plugins)).withNodeSourcePosition(needSourcePositions);
    this.config = baseConfig.withSkippedExceptionTypes(skippedExceptionTypes).withOmitAssertions(TruffleCompilerOptions.getValue(TruffleExcludeAssertions)).withBytecodeExceptionMode(
                    BytecodeExceptionMode.ExplicitOnly);

    this.partialEvaluator = createPartialEvaluator();

    if (Debug.isEnabled()) {
        DebugEnvironment.ensureInitialized(TruffleCompilerOptions.getOptions(), graalTruffleRuntime.getRequiredGraalCapability(SnippetReflectionProvider.class));
    }

    graalTruffleRuntime.reinstallStubs();
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
public static void propagateLoopCount(final long count) {
  CompilerAsserts.neverPartOfCompilation("Primitive.pLC(.)");

  // we need to skip the primitive and get to the method that called the primitive
  FrameInstance caller = Truffle.getRuntime().getCallerFrame();

  RootCallTarget ct = (RootCallTarget) caller.getCallTarget(); // caller method
  Invokable m = (Invokable) ct.getRootNode();

  if (m instanceof Primitive) {
    // the caller is a primitive, that doesn't help, we need to skip it and
    // find a proper method
    m = getNextMethodOnStack();
  }

  if (m != null && !(m instanceof Primitive)) {
    m.propagateLoopCountThroughoutMethodScope(count);
  }
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
public AbstractWhileNode(final SBlock rcvr, final SBlock arg,
    final boolean predicateBool, final SourceSection source) {
  super(false, source);

  CallTarget callTargetCondition = rcvr.getMethod().getCallTarget();
  conditionValueSend = Truffle.getRuntime().createDirectCallNode(
      callTargetCondition);

  CallTarget callTargetBody = arg.getMethod().getCallTarget();
  bodyValueSend = Truffle.getRuntime().createDirectCallNode(
      callTargetBody);

  this.predicateBool = predicateBool;
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
public IfTrueIfFalseMessageNode(final IfTrueIfFalseMessageNode node) {
  super(false, node.sourceSection);

  trueMethod = node.trueMethod;
  if (node.trueMethod != null) {
    trueValueSend = Truffle.getRuntime().createDirectCallNode(
        trueMethod.getCallTarget());
  }

  falseMethod = node.falseMethod;
  if (node.falseMethod != null) {
    falseValueSend = Truffle.getRuntime().createDirectCallNode(
        falseMethod.getCallTarget());
  }
  call = Truffle.getRuntime().createIndirectCallNode();
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    CharStream in = new ANTLRInputStream(new FileInputStream(args[0]));
    TuberBasicLexer lexer = new TuberBasicLexer(in);
    TokenStream tokens = new CommonTokenStream(lexer);
    TuberBasicParser parser = new TuberBasicParser(tokens);
    ParserRuleContext tree = parser.statements();

    Visitor visitor = new Visitor();
    TuberNode ast = visitor.visit(tree);

    TruffleRuntime runtime = Truffle.getRuntime();
    TuberRootNode rootNode = new TuberRootNode(ast);
    CallTarget target = runtime.createCallTarget(rootNode);
    Object result = target.call();
    System.out.println(result);
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
public static int stackDepth() {
	final StringBuilder str = new StringBuilder();
	Truffle.getRuntime().iterateFrames(new FrameInstanceVisitor<Integer>() {

		@Override
		public Integer visitFrame(FrameInstance frameInstance) {
			CallTarget callTarget = frameInstance.getCallTarget();
			RootNode rn = ((RootCallTarget) callTarget).getRootNode();
			if (rn.getClass().getName().contains("DynSemRuleForeignAccess")) {
				return 1;
			}
			str.append(" ");
			return null;
		}

	});
	return str.length();
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
@ExplodeLoop
public RuleResult execute(final Object[] arguments) {
	CompilerAsserts.compilationConstant(rules.length);
	PatternMatchFailure lastFailure = null;
	for (int i = 0; i < rules.length; i++) {
		try {
			final Rule r = rules[i];
			return r.execute(Truffle.getRuntime().createVirtualFrame(arguments, r.getFrameDescriptor()));
		} catch (PatternMatchFailure pmfx) {
			lastFailure = pmfx;
		}
	}
	// there are no rules or all rules have failed. we throw a soft exception to allow alternative rules to be tried
	if (lastFailure != null) {
		throw lastFailure;
	} else {
		throw PatternMatchFailure.INSTANCE;
	}
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
public void interpret(Path path) throws IOException {
  byte[] data = Files.readAllBytes(path);
  
  TruffleRuntime runtime = Truffle.getRuntime();
  System.out.println("using " + runtime.getName());
  
  Parser parser = new Parser(data);
  while(!parser.end()) {
    List list = parser.parseList();
    
    FrameDescriptor frameDescriptor = new FrameDescriptor();
    Node node = createAST(list, frameDescriptor);
    EvalNode evalNode = new EvalNode(node);
    CallTarget callTarget = runtime.createCallTarget(evalNode, frameDescriptor);
    callTarget.call();
  }
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
public static void propagateLoopCount(final long count) {
  CompilerAsserts.neverPartOfCompilation("Primitive.pLC(.)");

  // we need to skip the primitive and get to the method that called the primitive
  FrameInstance caller = Truffle.getRuntime().getCallerFrame();

  RootCallTarget ct = (RootCallTarget) caller.getCallTarget(); // caller method
  Invokable m = (Invokable) ct.getRootNode();

  if (m instanceof Primitive) {
    // the caller is a primitive, that doesn't help, we need to skip it and
    // find a proper method
    m = getNextMethodOnStack();
  }

  if (m != null && !(m instanceof Primitive)) {
    m.propagateLoopCountThroughoutLexicalScope(count);
  }
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
public IfTrueIfFalseMessageNode(final SourceSection source, final Object[] args) {
  super(source);
  if (args[1] instanceof SBlock) {
    SBlock trueBlock = (SBlock) args[1];
    trueMethod = trueBlock.getMethod();
    trueValueSend = Truffle.getRuntime().createDirectCallNode(
        trueMethod.getCallTarget());
  } else {
    trueMethod = null;
  }

  if (args[2] instanceof SBlock) {
    SBlock falseBlock = (SBlock) args[2];
    falseMethod = falseBlock.getMethod();
    falseValueSend = Truffle.getRuntime().createDirectCallNode(
        falseMethod.getCallTarget());
  } else {
    falseMethod = null;
  }

  call = Truffle.getRuntime().createIndirectCallNode();
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
@Override
protected CallTarget parse(ParsingRequest request) throws Exception {
    Source source = request.getSource();

    try(IndexedPushbackReader r = new IndexedPushbackReader(source.getReader())) {
        List<CallTarget> callTargets = new ArrayList<>();

        while(true) {
            int startIndex = r.getPosition();

            Object form = Reader.read(r);

            if (form == null) {
                break;
            }

            RootNode expr = Analyzer.analyzeRoot(this, form, source.createSection(startIndex, r.getPosition()-startIndex-1));
            callTargets.add(Truffle.getRuntime().createCallTarget(expr));
        }

        SequenceNode node = new SequenceNode(callTargets.toArray(new CallTarget[0]));
        RootNode root = new RootNode(this, null, node);
        //NodeUtil.printCompactTree(System.out, root);

        return Truffle.getRuntime().createCallTarget(root);
        //return Truffle.getRuntime().createCallTarget(new RootNode(null, null, doNode));
    }
}
 

import com.oracle.truffle.api.Truffle; //导入依赖的package包/类
public void registerFunction(String name, Function f) {
    functions.compute(name, (k, v) -> {
        if (v != null) {
            v.assumption.invalidate();
        }
        return new RegisteredFunction(f, Truffle.getRuntime().createAssumption(name));
    });
    f.setName(name);
}