com.oracle.truffle.api.Truffle Java Examples

private void addObjectsFromTruffleFrames() {
    CompilerAsserts.neverPartOfCompilation();
    Truffle.getRuntime().iterateFrames(frameInstance -> {
        final Frame current = frameInstance.getFrame(FrameInstance.FrameAccess.READ_ONLY);
        if (!FrameAccess.isTruffleSqueakFrame(current)) {
            return null;
        }
        for (final Object argument : current.getArguments()) {
            addIfUnmarked(argument);
        }
        final CompiledCodeObject blockOrMethod = FrameAccess.getBlockOrMethod(current);
        addIfUnmarked(FrameAccess.getContext(current, blockOrMethod));
        for (final FrameSlot slot : blockOrMethod.getStackSlotsUnsafe()) {
            if (slot == null) {
                return null; // Stop here, slot has not (yet) been created.
            }
            if (current.isObject(slot)) {
                addIfUnmarked(FrameUtil.getObjectSafe(current, slot));
            }
        }
        return null;
    });
}
 

@TruffleBoundary
public static MaterializedFrame findFrameForMarker(final FrameMarker frameMarker) {
    CompilerDirectives.bailout("Finding materializable frames should never be part of compiled code as it triggers deopts");
    LogUtils.ITERATE_FRAMES.fine("Iterating frames to find a marker...");
    final Frame frame = Truffle.getRuntime().iterateFrames(frameInstance -> {
        final Frame current = frameInstance.getFrame(FrameInstance.FrameAccess.READ_ONLY);
        if (!isTruffleSqueakFrame(current)) {
            return null;
        }
        LogUtils.ITERATE_FRAMES.fine(() -> "..." + FrameAccess.getMethod(current).toString());
        if (frameMarker == getMarker(current)) {
            return frameInstance.getFrame(FrameInstance.FrameAccess.MATERIALIZE);
        }
        return null;
    });
    if (frame == null) {
        throw SqueakException.create("Could not find frame for:", frameMarker);
    } else {
        return frame.materialize();
    }
}
 

@Override
protected CallTarget parse(ParsingRequest request) throws Exception {
    return Truffle.getRuntime().createCallTarget(new RootNode(this) {

        @CompilationFinal private ContextReference<Env> reference;

        @Override
        public Object execute(VirtualFrame frame) {
            return parseAndEval();
        }

        @TruffleBoundary
        private Object parseAndEval() {
            if (reference == null) {
                CompilerDirectives.transferToInterpreterAndInvalidate();
                this.reference = lookupContextReference(EvalLang.class);
            }
            Source aPlusB = Source.newBuilder("hashemi", "a + b", "plus.hashem").build();
            return reference.get().parsePublic(aPlusB, "a", "b").call(30, 12);
        }
    });
}
 

private ContextObject(final ContextObject original) {
    super(original);
    final CompiledCodeObject code = FrameAccess.getBlockOrMethod(original.truffleFrame);
    hasModifiedSender = original.hasModifiedSender();
    escaped = original.escaped;
    size = original.size;
    // Create shallow copy of Truffle frame
    truffleFrame = Truffle.getRuntime().createMaterializedFrame(original.truffleFrame.getArguments().clone(), code.getFrameDescriptor());
    // Copy frame slot values
    FrameAccess.initializeMarker(truffleFrame, code);
    FrameAccess.setContext(truffleFrame, code, this);
    FrameAccess.setInstructionPointer(truffleFrame, code, FrameAccess.getInstructionPointer(original.truffleFrame, code));
    FrameAccess.setStackPointer(truffleFrame, code, FrameAccess.getStackPointer(original.truffleFrame, code));
    // Copy stack
    final int numStackSlots = code.getNumStackSlots();
    for (int i = 0; i < numStackSlots; i++) {
        final FrameSlot slot = code.getStackSlot(i);
        final Object value = original.truffleFrame.getValue(slot);
        if (value != null) {
            FrameAccess.setStackSlot(truffleFrame, slot, value);
        } else {
            break; // This and all following slots are not in use.
        }
    }
}
 

@TruffleBoundary
public final RootCallTarget getResumptionCallTarget(final ContextObject context) {
    if (resumptionCallTarget == null) {
        CompilerDirectives.transferToInterpreterAndInvalidate();
        resumptionCallTarget = Truffle.getRuntime().createCallTarget(ResumeContextRootNode.create(SqueakLanguage.getContext().getLanguage(), context));
    } else {
        final ResumeContextRootNode resumeNode = (ResumeContextRootNode) resumptionCallTarget.getRootNode();
        if (resumeNode.getActiveContext() != context) {
            /**
             * This is a trick: we set the activeContext of the {@link ResumeContextRootNode} to
             * the given context to be able to reuse the call target.
             */
            resumeNode.setActiveContext(context);
        }
    }
    return resumptionCallTarget;
}
 

@Override
protected CallTarget parse(final ParsingRequest request) throws Exception {
    final SqueakImageContext image = getContext();
    final Source source = request.getSource();
    if (source.hasBytes()) {
        image.setImagePath(source.getPath());
        return image.getSqueakImage().asCallTarget();
    } else {
        image.ensureLoaded();
        if (source.isInternal()) {
            image.printToStdOut(MiscUtils.format("Evaluating '%s'...", source.getCharacters().toString()));
        }
        return Truffle.getRuntime().createCallTarget(image.getDoItContextNode(source));
    }
}
 

public static void printSqStackTrace() {
    CompilerAsserts.neverPartOfCompilation("For debugging purposes only");
    final boolean isCIBuild = System.getenv().containsKey("GITHUB_ACTIONS");
    final int[] depth = new int[1];
    final Object[] lastSender = new Object[]{null};
    final PrintWriter err = SqueakLanguage.getContext().getError();
    err.println("== Truffle stack trace ===========================================================");
    Truffle.getRuntime().iterateFrames(frameInstance -> {
        if (depth[0]++ > 50 && isCIBuild) {
            return null;
        }
        final Frame current = frameInstance.getFrame(FrameInstance.FrameAccess.READ_ONLY);
        if (!FrameAccess.isTruffleSqueakFrame(current)) {
            return null;
        }
        final CompiledMethodObject method = FrameAccess.getMethod(current);
        lastSender[0] = FrameAccess.getSender(current);
        final Object marker = FrameAccess.getMarker(current, method);
        final Object context = FrameAccess.getContext(current, method);
        final String prefix = FrameAccess.getClosure(current) == null ? "" : "[] in ";
        final String argumentsString = ArrayUtils.toJoinedString(", ", FrameAccess.getReceiverAndArguments(current));
        err.println(MiscUtils.format("%s%s #(%s) [marker: %s, context: %s, sender: %s]", prefix, method, argumentsString, marker, context, lastSender[0]));
        return null;
    });
    if (lastSender[0] instanceof ContextObject) {
        err.println("== Squeak frames ================================================================");
        printSqStackTrace((ContextObject) lastSender[0]);
    }
}
 

protected static Object evaluate(final String expression) {
    context.enter();
    try {
        final ExecuteTopLevelContextNode doItContextNode = image.getDoItContextNode(expression);
        return Truffle.getRuntime().createCallTarget(doItContextNode).call();
    } finally {
        context.leave();
    }
}
 

public MaterializedFrame getOrCreateTruffleFrame() {
    if (truffleFrame == null) {
        CompilerDirectives.transferToInterpreterAndInvalidate();
        // Method is unknown, use dummy frame instead
        final Object[] dummyArguments = FrameAccess.newDummyWith(null, NilObject.SINGLETON, null, new Object[2]);
        final CompiledMethodObject dummyMethod = SqueakLanguage.getContext().dummyMethod;
        truffleFrame = Truffle.getRuntime().createMaterializedFrame(dummyArguments, dummyMethod.getFrameDescriptor());
        FrameAccess.setInstructionPointer(truffleFrame, dummyMethod, 0);
        FrameAccess.setStackPointer(truffleFrame, dummyMethod, 1);
    }
    return truffleFrame;
}
 

public static Throwable fillInMumblerStackTrace(Throwable t) {
    final List<StackTraceElement> stackTrace = new ArrayList<>();
    Truffle.getRuntime().iterateFrames((FrameInstanceVisitor<Void>) frame -> {
        Node callNode = frame.getCallNode();
        if (callNode == null) {
            return null;
        }
        RootNode root = callNode.getRootNode();

        /*
         * There should be no RootNodes other than SLRootNodes on the stack. Just for the
         * case if this would change.
         */
        String methodName = "$unknownFunction";
        if (root instanceof MumblerRootNode) {
            methodName = ((MumblerRootNode) root).name;
        }

        SourceSection sourceSection = callNode.getEncapsulatingSourceSection();
        Source source = sourceSection != null ? sourceSection.getSource() : null;
        String sourceName = source != null ? source.getName() : null;
        int lineNumber;
        try {
            lineNumber = sourceSection != null ? sourceSection.getStartLine() : -1;
        } catch (UnsupportedOperationException e) {
            /*
             * SourceSection#getLineLocation() may throw an UnsupportedOperationException.
             */
            lineNumber = -1;
        }
        stackTrace.add(new StackTraceElement("mumbler", methodName, sourceName, lineNumber));
        return null;
    });
    t.setStackTrace(stackTrace.toArray(new StackTraceElement[stackTrace.size()]));
    return t;
}
 

protected CallTarget createUncachedLoop(Object source, GrCUDAContext context) {
    ConcurrentHashMap<Class<?>, CallTarget> uncachedCallTargets = context.getMapCallTargets();
    DynamicDispatchLibrary dispatch = DynamicDispatchLibrary.getFactory().getUncached(source);
    Class<?> clazz = dispatch.dispatch(source);
    if (clazz == null) {
        clazz = source.getClass();
    }
    return uncachedCallTargets.computeIfAbsent(clazz, c -> Truffle.getRuntime().createCallTarget(new LoopRootNode(source, c)));
}
 

public static MumblerFunction createBuiltinFunction(
        MumblerLanguage lang,
        NodeFactory<? extends BuiltinNode> factory,
        VirtualFrame outerFrame) {
    int argumentCount = factory.getExecutionSignature().size();
    MumblerNode[] argumentNodes = new MumblerNode[argumentCount];
    for (int i=0; i<argumentCount; i++) {
        argumentNodes[i] = new ReadArgumentNode(i);
    }
    BuiltinNode node = factory.createNode((Object) argumentNodes);
    return new MumblerFunction(Truffle.getRuntime().createCallTarget(
            new MumblerRootNode(lang, new MumblerNode[] {node},
                    new FrameDescriptor())));
}
 

@Test
public void sdkAndTruffleLanguageAPIAndSLInSeparateClassLoaders() throws Exception {
    final ProtectionDomain sdkDomain = Engine.class.getProtectionDomain();
    Assume.assumeNotNull(sdkDomain);
    Assume.assumeNotNull(sdkDomain.getCodeSource());
    URL sdkURL = sdkDomain.getCodeSource().getLocation();
    Assume.assumeNotNull(sdkURL);

    URL truffleURL = Truffle.class.getProtectionDomain().getCodeSource().getLocation();
    Assume.assumeNotNull(truffleURL);

    URL slURL = HashemLanguage.class.getProtectionDomain().getCodeSource().getLocation();
    Assume.assumeNotNull(slURL);

    ClassLoader parent = Engine.class.getClassLoader().getParent();

    URLClassLoader sdkLoader = new URLClassLoader(new URL[]{sdkURL}, parent);
    boolean sdkLoaderLoadsTruffleLanguage;
    try {
        Class.forName("com.oracle.truffle.api.TruffleLanguage", false, sdkLoader);
        sdkLoaderLoadsTruffleLanguage = true;
    } catch (ClassNotFoundException cnf) {
        sdkLoaderLoadsTruffleLanguage = false;
    }
    Assume.assumeFalse(sdkLoaderLoadsTruffleLanguage);
    URLClassLoader truffleLoader = new URLClassLoader(new URL[]{truffleURL}, sdkLoader);
    URLClassLoader slLoader = new URLClassLoader(new URL[]{slURL}, truffleLoader);
    Thread.currentThread().setContextClassLoader(slLoader);

    Class<?> engineClass = sdkLoader.loadClass(Engine.class.getName());
    Object engine = engineClass.getMethod("create").invoke(null);
    assertNotNull("Engine has been created", engine);

    Map<?, ?> languages = (Map<?, ?>) engineClass.getMethod("getLanguages").invoke(engine);
    Object lang = languages.get("hashemi");
    assertNotNull("SL language found: " + languages, lang);
}
 

@TruffleBoundary
private static String createStackTrace() {
    final StringBuilder str = new StringBuilder();

    Truffle.getRuntime().iterateFrames(new FrameInstanceVisitor<Integer>() {
        private int skip = 1; // skip stack trace builtin

        @Override
        public Integer visitFrame(FrameInstance frameInstance) {
            if (skip > 0) {
                skip--;
                return null;
            }
            CallTarget callTarget = frameInstance.getCallTarget();
            Frame frame = frameInstance.getFrame(FrameAccess.READ_ONLY);
            RootNode rn = ((RootCallTarget) callTarget).getRootNode();
            // ignore internal or interop stack frames
            if (rn.isInternal() || rn.getLanguageInfo() == null) {
                return 1;
            }
            if (str.length() > 0) {
                str.append(System.getProperty("line.separator"));
            }
            str.append("Frame: ").append(rn.toString());
            FrameDescriptor frameDescriptor = frame.getFrameDescriptor();
            for (FrameSlot s : frameDescriptor.getSlots()) {
                str.append(", ").append(s.getIdentifier()).append("=").append(frame.getValue(s));
            }
            return null;
        }
    });
    return str.toString();
}
 

private static boolean isProfilingEnabled() {
    return Truffle.getRuntime().isProfilingEnabled();
}
 

private MaterializedFrame initGlobalFrame(MumblerLanguage lang) {
    VirtualFrame frame = Truffle.getRuntime().createVirtualFrame(null,
            this.globalFrameDescriptor);
    addGlobalFunctions(lang, frame);
    return frame.materialize();
}
 

public LoopNode(InvokeNode callNode) {
    this.callString = callNode.toString();
    this.loopNode = Truffle.getRuntime().createLoopNode(
            new LoopReapeatingNode(callNode));
}
 

protected static VirtualFrame createTestFrame(final CompiledMethodObject code) {
    final Object[] arguments = FrameAccess.newWith(code, NilObject.SINGLETON, null, new Object[]{NilObject.SINGLETON});
    return Truffle.getRuntime().createVirtualFrame(arguments, code.getFrameDescriptor());
}
 

public RootCallTarget asCallTarget() {
    return Truffle.getRuntime().createCallTarget(new SqueakImageNode(this));
}
 

public DirectDispatchNode(DispatchNode next, CallTarget callTarget) {
    this.cachedCallTarget = callTarget;
    this.callCachedTargetNode = Truffle.getRuntime().createDirectCallNode(
            this.cachedCallTarget);
    this.nextNode = next;
}
 

public static MumblerFunction create(MumblerLanguage lang, FrameSlot[] arguments,
                                     MumblerNode[] bodyNodes, FrameDescriptor frameDescriptor) {
    return new MumblerFunction(
            Truffle.getRuntime().createCallTarget(
                    MumblerRootNode.create(lang, arguments, bodyNodes, frameDescriptor)));
}
 

@TruffleBoundary
public Object evaluate(final String sourceCode) {
    final Source source = Source.newBuilder(SqueakLanguageConfig.NAME, sourceCode, "<image#evaluate>").build();
    return Truffle.getRuntime().createCallTarget(getDoItContextNode(source)).call();
}
 

@Specialization
protected static final Object doGet(@SuppressWarnings("unused") final Object receiver) {
    return JavaObjectWrapper.wrap(Truffle.getRuntime());
}
 

@TruffleBoundary
@Specialization(guards = {"!receiver.hasMaterializedSender()"})
protected final AbstractSqueakObject findNextAvoidingMaterialization(final ContextObject receiver) {
    final boolean[] foundMyself = new boolean[1];
    final Object[] lastSender = new Object[1];
    final ContextObject result = Truffle.getRuntime().iterateFrames(frameInstance -> {
        final Frame current = frameInstance.getFrame(FrameInstance.FrameAccess.READ_ONLY);
        if (!FrameAccess.isTruffleSqueakFrame(current)) {
            final RootNode rootNode = ((RootCallTarget) frameInstance.getCallTarget()).getRootNode();
            if (rootNode.isInternal() || rootNode.getLanguageInfo().getId().equals(SqueakLanguageConfig.ID)) {
                /* Skip internal and all other nodes that belong to TruffleSqueak. */
                return null;
            } else {
                /*
                 * Found a frame of another language. Stop here by returning the receiver
                 * context. This special case will be handled later on.
                 */
                return receiver;
            }
        }
        final ContextObject context = FrameAccess.getContext(current);
        if (!foundMyself[0]) {
            if (context == receiver) {
                foundMyself[0] = true;
            }
        } else {
            if (FrameAccess.getMethod(current).isExceptionHandlerMarked()) {
                if (context != null) {
                    return context;
                } else {
                    return ContextObject.create(frameInstance);
                }
            } else {
                lastSender[0] = FrameAccess.getSender(current);
            }
        }
        return null;
    });
    if (result == receiver) {
        /*
         * Foreign frame found during frame iteration. Inject a fake context which will
         * throw the Smalltalk exception as polyglot exception.
         */
        return getInteropExceptionThrowingContext();
    } else if (result == null) {
        if (!foundMyself[0]) {
            return findNext(receiver); // Fallback to other version.
        }
        if (lastSender[0] instanceof ContextObject) {
            return findNext((ContextObject) lastSender[0]);
        } else {
            return NilObject.SINGLETON;
        }
    } else {
        return result;
    }
}
 

@Override
protected CallTarget parse(ParsingRequest request) throws Exception {
    Source source = request.getSource();
    Map<String, RootCallTarget> functions;
    /*
     * Parse the provided source. At this point, we do not have a SLContext yet. Registration of
     * the functions with the SLContext happens lazily in SLEvalRootNode.
     */
    if (request.getArgumentNames().isEmpty()) {
        functions = HashemLanguageParser.parseHashemiLang(this, source);
    } else {
        Source requestedSource = request.getSource();
        StringBuilder sb = new StringBuilder();
        sb.append("bebin azinja(");
        String sep = "";
        for (String argumentName : request.getArgumentNames()) {
            sb.append(sep);
            sb.append(argumentName);
            sep = ",";
        }
        sb.append(") { return ");
        sb.append(request.getSource().getCharacters());
        sb.append(";}");
        String language = requestedSource.getLanguage() == null ? ID : requestedSource.getLanguage();
        Source decoratedSource = Source.newBuilder(language, sb.toString(), request.getSource().getName()).build();
        functions = HashemLanguageParser.parseHashemiLang(this, decoratedSource);
    }

    RootCallTarget main = functions.get("azinja");
    RootNode evalMain;
    if (main != null) {
        /*
         * We have a main function, so "evaluating" the parsed source means invoking that main
         * function. However, we need to lazily register functions into the SLContext first, so
         * we cannot use the original SLRootNode for the main function. Instead, we create a new
         * SLEvalRootNode that does everything we need.
         */
        evalMain = new HashemEvalRootNode(this, main, functions);
    } else {
        /*
         * Even without a main function, "evaluating" the parsed source needs to register the
         * functions into the SLContext.
         */
        evalMain = new HashemEvalRootNode(this, null, functions);
    }
    return Truffle.getRuntime().createCallTarget(evalMain);
}
 

protected final void initializeCallTargetUnsafe() {
    callTarget = Truffle.getRuntime().createCallTarget(EnterCodeNode.create(SqueakLanguage.getContext().getLanguage(), this));
}
 

protected CallTarget createLoop(Object source) {
    return Truffle.getRuntime().createCallTarget(new LoopRootNode(source, null));
}
 

protected LoopRootNode(Object source, Class<?> clazz) {
    super(GrCUDALanguage.getCurrentLanguage(), DESCRIPTOR);
    this.clazz = clazz;
    this.loop = Truffle.getRuntime().createLoopNode(new RepeatingLoopNode(InteropLibrary.getFactory().create(source)));
}
 

@Override
protected CallTarget parse(ParsingRequest request) {
    ExpressionNode expression = new ParserAntlr().parse(request.getSource());
    GrCUDARootNode newParserRoot = new GrCUDARootNode(this, expression);
    return Truffle.getRuntime().createCallTarget(newParserRoot);
}
 

protected HashemBebin(HashemLanguage language, String name) {
    this.name = name;
    this.callTarget = Truffle.getRuntime().createCallTarget(new HashemUndefinedBebinRootNode(language, name));
    this.callTargetStable = new CyclicAssumption(name);
}