Examples with Backend org.graalvm.compiler.core.target.Backend used on opensource projects

Example 1 with Backend

use of org.graalvm.compiler.core.target.Backend in project graal by oracle.

the class HotSpotTruffleCompilerImpl method create.

public static HotSpotTruffleCompilerImpl create(TruffleCompilerRuntime runtime) {
    HotSpotGraalRuntimeProvider hotspotGraalRuntime = (HotSpotGraalRuntimeProvider) runtime.getGraalRuntime();
    Backend backend = hotspotGraalRuntime.getHostBackend();
    OptionValues options = TruffleCompilerOptions.getOptions();
    Suites suites = backend.getSuites().getDefaultSuites(options);
    LIRSuites lirSuites = backend.getSuites().getDefaultLIRSuites(options);
    GraphBuilderPhase phase = (GraphBuilderPhase) backend.getSuites().getDefaultGraphBuilderSuite().findPhase(GraphBuilderPhase.class).previous();
    Plugins plugins = phase.getGraphBuilderConfig().getPlugins();
    SnippetReflectionProvider snippetReflection = hotspotGraalRuntime.getRequiredCapability(SnippetReflectionProvider.class);
    return new HotSpotTruffleCompilerImpl(hotspotGraalRuntime, runtime, plugins, suites, lirSuites, backend, snippetReflection);
}

Example 2 with Backend

use of org.graalvm.compiler.core.target.Backend in project graal by oracle.

the class SubstrateGraalUtils method compileGraph.

@SuppressWarnings("try")
public static CompilationResult compileGraph(RuntimeConfiguration runtimeConfig, Suites suites, LIRSuites lirSuites, final SharedMethod method, final StructuredGraph graph) {
    assert runtimeConfig != null : "no runtime";
    if (Options.ForceDumpGraphsBeforeCompilation.getValue()) {
        /*
             * forceDump is often used during debugging, and we want to make sure that it keeps
             * working, i.e., does not lead to image generation problems when adding a call to it.
             * This code ensures that forceDump is seen as reachable for all images that include
             * Graal, because it is conditional on a runtime option.
             */
        graph.getDebug().forceDump(graph, "Force dump before compilation");
    }
    String methodName = method.format("%h.%n");
    try (DebugContext debug = graph.getDebug();
        Indent indent = debug.logAndIndent("compile graph %s for method %s", graph, methodName)) {
        OptimisticOptimizations optimisticOpts = OptimisticOptimizations.ALL.remove(OptimisticOptimizations.Optimization.UseLoopLimitChecks);
        final Backend backend = runtimeConfig.lookupBackend(method);
        try (Indent indent2 = debug.logAndIndent("do compilation")) {
            SubstrateCompilationResult result = new SubstrateCompilationResult(graph.compilationId(), method.format("%H.%n(%p)"));
            GraalCompiler.compileGraph(graph, method, backend.getProviders(), backend, null, optimisticOpts, null, suites, lirSuites, result, CompilationResultBuilderFactory.Default);
            return result;
        }
    }
}

Example 3 with Backend

use of org.graalvm.compiler.core.target.Backend in project graal by oracle.

the class NativeImageGenerator method registerGraphBuilderPlugins.

public static void registerGraphBuilderPlugins(FeatureHandler featureHandler, RuntimeConfiguration runtimeConfig, HostedProviders providers, AnalysisMetaAccess aMetaAccess, AnalysisUniverse aUniverse, HostedMetaAccess hMetaAccess, HostedUniverse hUniverse, NativeLibraries nativeLibs, ImageClassLoader loader, boolean analysis, boolean hosted) {
    assert !analysis || hosted : "analysis must always be hosted";
    GraphBuilderConfiguration.Plugins plugins = new GraphBuilderConfiguration.Plugins(new SubstitutionInvocationPlugins());
    WordOperationPlugin wordOperationPlugin = new WordOperationPlugin(providers.getSnippetReflection(), providers.getWordTypes());
    SubstrateReplacements replacements = (SubstrateReplacements) providers.getReplacements();
    plugins.appendInlineInvokePlugin(replacements);
    plugins.appendNodePlugin(new IntrinsifyMethodHandlesInvocationPlugin(providers, aUniverse, hUniverse));
    plugins.appendNodePlugin(new DeletedFieldsPlugin());
    plugins.appendNodePlugin(new InjectedAccessorsPlugin());
    plugins.appendNodePlugin(new ConstantFoldLoadFieldPlugin());
    plugins.appendNodePlugin(new CInterfaceInvocationPlugin(providers.getMetaAccess(), providers.getSnippetReflection(), providers.getWordTypes(), nativeLibs));
    plugins.appendNodePlugin(new LocalizationFeature.CharsetNodePlugin());
    plugins.appendInlineInvokePlugin(wordOperationPlugin);
    plugins.appendTypePlugin(wordOperationPlugin);
    plugins.appendTypePlugin(new TrustedInterfaceTypePlugin());
    plugins.appendNodePlugin(wordOperationPlugin);
    plugins.appendNodePlugin(new ImplicitExceptionsPlugin(providers.getMetaAccess(), providers.getForeignCalls()));
    featureHandler.forEachGraalFeature(feature -> feature.registerNodePlugins(analysis ? aMetaAccess : hMetaAccess, plugins, analysis, hosted));
    HostedSnippetReflectionProvider hostedSnippetReflection = new HostedSnippetReflectionProvider((SVMHost) aUniverse.getHostVM());
    NodeIntrinsificationProvider nodeIntrinsificationProvider = new NodeIntrinsificationProvider(providers.getMetaAccess(), hostedSnippetReflection, providers.getForeignCalls(), providers.getLowerer(), providers.getWordTypes());
    for (Class<? extends NodeIntrinsicPluginFactory> factoryClass : loader.findSubclasses(NodeIntrinsicPluginFactory.class)) {
        if (!Modifier.isAbstract(factoryClass.getModifiers()) && !factoryClass.getName().contains("hotspot")) {
            NodeIntrinsicPluginFactory factory;
            try {
                factory = factoryClass.newInstance();
            } catch (InstantiationException | IllegalAccessException ex) {
                throw VMError.shouldNotReachHere(ex);
            }
            factory.registerPlugins(plugins.getInvocationPlugins(), nodeIntrinsificationProvider);
        }
    }
    BytecodeProvider replacementBytecodeProvider = replacements.getDefaultReplacementBytecodeProvider();
    StandardGraphBuilderPlugins.registerInvocationPlugins(providers.getMetaAccess(), providers.getSnippetReflection(), plugins.getInvocationPlugins(), replacementBytecodeProvider, !hosted);
    AMD64GraphBuilderPlugins.register(plugins, replacementBytecodeProvider, (AMD64) ConfigurationValues.getTarget().arch, true);
    /*
         * When the context is hosted, i.e., ahead-of-time compilation, and after the analysis we
         * need the hosted meta access.
         */
    MetaAccessProvider pluginsMetaAccess = hosted && !analysis ? hMetaAccess : aMetaAccess;
    assert pluginsMetaAccess != null;
    SubstrateGraphBuilderPlugins.registerInvocationPlugins(pluginsMetaAccess, providers.getConstantReflection(), hostedSnippetReflection, plugins.getInvocationPlugins(), replacementBytecodeProvider, analysis);
    featureHandler.forEachGraalFeature(feature -> feature.registerInvocationPlugins(providers, hostedSnippetReflection, plugins.getInvocationPlugins(), hosted));
    providers.setGraphBuilderPlugins(plugins);
    replacements.setGraphBuilderPlugins(plugins);
    if (runtimeConfig != null && runtimeConfig.getProviders() instanceof HostedProviders) {
        ((HostedProviders) runtimeConfig.getProviders()).setGraphBuilderPlugins(plugins);
        for (Backend backend : runtimeConfig.getBackends()) {
            ((HostedProviders) backend.getProviders()).setGraphBuilderPlugins(plugins);
        }
    }
}

Example 4 with Backend

use of org.graalvm.compiler.core.target.Backend in project graal by oracle.

the class CompileQueue method defaultCompileFunction.

@SuppressWarnings("try")
private CompilationResult defaultCompileFunction(DebugContext debug, HostedMethod method, CompilationIdentifier compilationIdentifier, CompileReason reason, RuntimeConfiguration config) {
    if (NativeImageOptions.PrintAOTCompilation.getValue()) {
        System.out.println("Compiling " + method.format("%r %H.%n(%p)") + "  [" + reason + "]");
    }
    Backend backend = config.lookupBackend(method);
    StructuredGraph graph = method.compilationInfo.graph;
    assert graph != null : method;
    /* Operate on a copy, to keep the original graph intact for later inlining. */
    graph = graph.copyWithIdentifier(compilationIdentifier, debug);
    /* Check that graph is in good shape before compilation. */
    assert GraphOrder.assertSchedulableGraph(graph);
    try (DebugContext.Scope s = debug.scope("Compiling", graph, method, this)) {
        if (deoptimizeAll && method.compilationInfo.canDeoptForTesting) {
            insertDeoptTests(method, graph);
        }
        method.compilationInfo.numNodesBeforeCompilation = graph.getNodeCount();
        method.compilationInfo.numDeoptEntryPoints = graph.getNodes().filter(DeoptEntryNode.class).count();
        method.compilationInfo.numDuringCallEntryPoints = graph.getNodes(MethodCallTargetNode.TYPE).snapshot().stream().map(MethodCallTargetNode::invoke).filter(invoke -> method.compilationInfo.isDeoptEntry(invoke.bci(), true, false)).count();
        Suites suites = method.compilationInfo.isDeoptTarget() ? deoptTargetSuites : regularSuites;
        LIRSuites lirSuites = method.compilationInfo.isDeoptTarget() ? deoptTargetLIRSuites : regularLIRSuites;
        CompilationResult result = new CompilationResult(compilationIdentifier, method.format("%H.%n(%p)")) {

            @Override
            public void close() {
            /*
                     * Do nothing, we do not want our CompilationResult to be closed because we
                     * aggregate all data items and machine code in the native image heap.
                     */
            }
        };
        try (Indent indent = debug.logAndIndent("compile %s", method)) {
            GraalCompiler.compileGraph(graph, method, backend.getProviders(), backend, null, optimisticOpts, method.getProfilingInfo(), suites, lirSuites, result, new HostedCompilationResultBuilderFactory());
        }
        method.getProfilingInfo().setCompilerIRSize(StructuredGraph.class, method.compilationInfo.graph.getNodeCount());
        method.compilationInfo.numNodesAfterCompilation = graph.getNodeCount();
        if (method.compilationInfo.isDeoptTarget()) {
            assert verifyDeoptTarget(method, result);
        }
        for (Infopoint infopoint : result.getInfopoints()) {
            if (infopoint instanceof Call) {
                Call call = (Call) infopoint;
                HostedMethod callTarget = (HostedMethod) call.target;
                if (call.direct) {
                    ensureCompiled(callTarget, new DirectCallReason(method, reason));
                } else if (callTarget != null && callTarget.getImplementations() != null) {
                    for (HostedMethod impl : callTarget.getImplementations()) {
                        ensureCompiled(impl, new VirtualCallReason(method, callTarget, reason));
                    }
                }
            }
        }
        /* Shrink resulting code array to minimum size, to reduze memory footprint. */
        if (result.getTargetCode().length > result.getTargetCodeSize()) {
            result.setTargetCode(Arrays.copyOf(result.getTargetCode(), result.getTargetCodeSize()), result.getTargetCodeSize());
        }
        return result;
    } catch (Throwable ex) {
        GraalError error = ex instanceof GraalError ? (GraalError) ex : new GraalError(ex);
        error.addContext("method: " + method.format("%r %H.%n(%p)") + "  [" + reason + "]");
        throw error;
    }
}

Example 5 with Backend

use of org.graalvm.compiler.core.target.Backend in project graal by oracle.

the class SharedRuntimeConfigurationBuilder method build.

public SharedRuntimeConfigurationBuilder build() {
    wordTypes = new WordTypes(metaAccess, FrameAccess.getWordKind());
    Providers p = createProviders(null, null, null, null, null, null, null, null);
    StampProvider stampProvider = createStampProvider(p);
    p = createProviders(null, null, null, null, null, null, stampProvider, null);
    ConstantReflectionProvider constantReflection = createConstantReflectionProvider(p);
    ConstantFieldProvider constantFieldProvider = createConstantFieldProvider(p);
    createProviders(null, constantReflection, constantFieldProvider, null, null, null, stampProvider, null);
    SnippetReflectionProvider snippetReflection = createSnippetReflectionProvider();
    createProviders(null, constantReflection, constantFieldProvider, null, null, null, stampProvider, snippetReflection);
    ForeignCallsProvider foreignCalls = createForeignCallsProvider();
    p = createProviders(null, constantReflection, constantFieldProvider, foreignCalls, null, null, stampProvider, snippetReflection);
    LoweringProvider lowerer = createLoweringProvider(p);
    p = createProviders(null, constantReflection, constantFieldProvider, foreignCalls, lowerer, null, stampProvider, snippetReflection);
    Replacements replacements = createReplacements(p, snippetReflection);
    p = createProviders(null, constantReflection, constantFieldProvider, foreignCalls, lowerer, replacements, stampProvider, snippetReflection);
    EnumMap<ConfigKind, Backend> backends = new EnumMap<>(ConfigKind.class);
    for (ConfigKind config : ConfigKind.values()) {
        RegisterConfig registerConfig = new SubstrateAMD64RegisterConfig(config, metaAccess, ConfigurationValues.getTarget());
        CodeCacheProvider codeCacheProvider = createCodeCacheProvider(registerConfig);
        Providers newProviders = createProviders(codeCacheProvider, constantReflection, constantFieldProvider, foreignCalls, lowerer, replacements, stampProvider, snippetReflection);
        backends.put(config, GraalConfiguration.instance().createBackend(newProviders));
    }
    runtimeConfig = new RuntimeConfiguration(p, snippetReflection, backends, wordTypes);
    return this;
}