Examples with CoreProviders org.graalvm.compiler.nodes.spi.CoreProviders used on opensource projects

Example 16 with CoreProviders

use of org.graalvm.compiler.nodes.spi.CoreProviders in project graal by oracle.

the class CheckGraalInvariants method runTest.

@SuppressWarnings("try")
public static void runTest(InvariantsTool tool) {
    RuntimeProvider rt = Graal.getRequiredCapability(RuntimeProvider.class);
    Providers providers = rt.getHostBackend().getProviders();
    MetaAccessProvider metaAccess = providers.getMetaAccess();
    PhaseSuite<HighTierContext> graphBuilderSuite = new PhaseSuite<>();
    Plugins plugins = new Plugins(new InvocationPlugins());
    GraphBuilderConfiguration config = GraphBuilderConfiguration.getDefault(plugins).withEagerResolving(true).withUnresolvedIsError(true);
    graphBuilderSuite.appendPhase(new GraphBuilderPhase(config));
    HighTierContext context = new HighTierContext(providers, graphBuilderSuite, OptimisticOptimizations.NONE);
    Assume.assumeTrue(VerifyPhase.class.desiredAssertionStatus());
    String bootclasspath = tool.getClassPath();
    Assert.assertNotNull("Cannot find boot class path", bootclasspath);
    final List<String> classNames = new ArrayList<>();
    for (String path : bootclasspath.split(File.pathSeparator)) {
        if (tool.shouldProcess(path)) {
            try {
                if (path.equals(JRT_CLASS_PATH_ENTRY)) {
                    for (String className : ModuleSupport.getJRTGraalClassNames()) {
                        if (isGSON(className)) {
                            continue;
                        }
                        classNames.add(className);
                    }
                } else {
                    File file = new File(path);
                    if (!file.exists()) {
                        continue;
                    }
                    if (file.isDirectory()) {
                        Path root = file.toPath();
                        Files.walk(root).forEach(p -> {
                            String name = root.relativize(p).toString();
                            if (name.endsWith(".class") && !name.startsWith("META-INF/versions/")) {
                                String className = name.substring(0, name.length() - ".class".length()).replace('/', '.');
                                if (!(isInNativeImage(className) || isGSON(className))) {
                                    classNames.add(className);
                                }
                            }
                        });
                    } else {
                        final ZipFile zipFile = new ZipFile(file);
                        for (final Enumeration<? extends ZipEntry> entry = zipFile.entries(); entry.hasMoreElements(); ) {
                            final ZipEntry zipEntry = entry.nextElement();
                            String name = zipEntry.getName();
                            if (name.endsWith(".class") && !name.startsWith("META-INF/versions/")) {
                                String className = name.substring(0, name.length() - ".class".length()).replace('/', '.');
                                if (isInNativeImage(className) || isGSON(className)) {
                                    continue;
                                }
                                classNames.add(className);
                            }
                        }
                    }
                }
            } catch (IOException ex) {
                throw new AssertionError(ex);
            }
        }
    }
    Assert.assertFalse("Could not find graal jars on boot class path: " + bootclasspath, classNames.isEmpty());
    // Allows a subset of methods to be checked through use of a system property
    String property = System.getProperty(CheckGraalInvariants.class.getName() + ".filters");
    String[] filters = property == null ? null : property.split(",");
    OptionValues options = getInitialOptions();
    CompilerThreadFactory factory = new CompilerThreadFactory("CheckInvariantsThread");
    int availableProcessors = Runtime.getRuntime().availableProcessors();
    ThreadPoolExecutor executor = new ThreadPoolExecutor(availableProcessors, availableProcessors, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), factory);
    List<String> errors = Collections.synchronizedList(new ArrayList<>());
    List<VerifyPhase<CoreProviders>> verifiers = new ArrayList<>();
    // If you add a new type to test here, be sure to add appropriate
    // methods to the BadUsageWithEquals class below
    verifiers.add(new VerifyUsageWithEquals(Value.class));
    verifiers.add(new VerifyUsageWithEquals(Register.class));
    verifiers.add(new VerifyUsageWithEquals(RegisterCategory.class));
    verifiers.add(new VerifyUsageWithEquals(JavaType.class));
    verifiers.add(new VerifyUsageWithEquals(JavaMethod.class));
    verifiers.add(new VerifyUsageWithEquals(JavaField.class));
    verifiers.add(new VerifyUsageWithEquals(LocationIdentity.class));
    verifiers.add(new VerifyUsageWithEquals(LIRKind.class));
    verifiers.add(new VerifyUsageWithEquals(ArithmeticOpTable.class));
    verifiers.add(new VerifyUsageWithEquals(ArithmeticOpTable.Op.class));
    verifiers.add(new VerifyDebugUsage());
    verifiers.add(new VerifyVirtualizableUsage());
    verifiers.add(new VerifyUpdateUsages());
    verifiers.add(new VerifyBailoutUsage());
    verifiers.add(new VerifySystemPropertyUsage());
    verifiers.add(new VerifyInstanceOfUsage());
    verifiers.add(new VerifyGraphAddUsage());
    verifiers.add(new VerifyGetOptionsUsage());
    verifiers.add(new VerifyUnsafeAccess());
    verifiers.add(new VerifyVariableCasts());
    verifiers.add(new VerifyIterableNodeType());
    verifiers.add(new VerifyArchUsageInPlugins());
    verifiers.add(new VerifyStatelessPhases());
    loadVerifiers(verifiers);
    VerifyFoldableMethods foldableMethodsVerifier = new VerifyFoldableMethods();
    if (tool.shouldVerifyFoldableMethods()) {
        verifiers.add(foldableMethodsVerifier);
    }
    tool.updateVerifiers(verifiers);
    for (Method m : BadUsageWithEquals.class.getDeclaredMethods()) {
        ResolvedJavaMethod method = metaAccess.lookupJavaMethod(m);
        try (DebugContext debug = new Builder(options).build()) {
            StructuredGraph graph = new StructuredGraph.Builder(options, debug, AllowAssumptions.YES).method(method).build();
            try (DebugCloseable s = debug.disableIntercept();
                DebugContext.Scope ds = debug.scope("CheckingGraph", graph, method)) {
                graphBuilderSuite.apply(graph, context);
                // update phi stamps
                graph.getNodes().filter(PhiNode.class).forEach(PhiNode::inferStamp);
                checkGraph(verifiers, context, graph);
                errors.add(String.format("Expected error while checking %s", m));
            } catch (VerificationError e) {
            // expected!
            } catch (Throwable e) {
                errors.add(String.format("Error while checking %s:%n%s", m, printStackTraceToString(e)));
            }
        }
    }
    Map<ResolvedJavaField, Set<ResolvedJavaMethod>> optionFieldUsages = initOptionFieldUsagesMap(tool, metaAccess, errors);
    ResolvedJavaType optionDescriptorsType = metaAccess.lookupJavaType(OptionDescriptors.class);
    if (errors.isEmpty()) {
        // Order outer classes before the inner classes
        classNames.sort((String a, String b) -> a.compareTo(b));
        // Initialize classes in single thread to avoid deadlocking issues during initialization
        List<Class<?>> classes = initializeClasses(tool, classNames);
        for (Class<?> c : classes) {
            String className = c.getName();
            executor.execute(() -> {
                try {
                    checkClass(c, metaAccess, verifiers);
                } catch (Throwable e) {
                    errors.add(String.format("Error while checking %s:%n%s", className, printStackTraceToString(e)));
                }
            });
            ResolvedJavaType type = metaAccess.lookupJavaType(c);
            List<ResolvedJavaMethod> methods = new ArrayList<>();
            try {
                methods.addAll(Arrays.asList(type.getDeclaredMethods()));
                methods.addAll(Arrays.asList(type.getDeclaredConstructors()));
            } catch (Throwable e) {
                errors.add(String.format("Error while checking %s:%n%s", className, printStackTraceToString(e)));
            }
            ResolvedJavaMethod clinit = type.getClassInitializer();
            if (clinit != null) {
                methods.add(clinit);
            }
            for (ResolvedJavaMethod method : methods) {
                if (Modifier.isNative(method.getModifiers()) || Modifier.isAbstract(method.getModifiers())) {
                // ignore
                } else {
                    String methodName = className + "." + method.getName();
                    if (matches(filters, methodName)) {
                        executor.execute(() -> {
                            try (DebugContext debug = new Builder(options).build()) {
                                boolean isSubstitution = method.getAnnotation(Snippet.class) != null;
                                StructuredGraph graph = new StructuredGraph.Builder(options, debug).method(method).setIsSubstitution(isSubstitution).build();
                                try (DebugCloseable s = debug.disableIntercept();
                                    DebugContext.Scope ds = debug.scope("CheckingGraph", graph, method)) {
                                    checkMethod(method);
                                    graphBuilderSuite.apply(graph, context);
                                    // update phi stamps
                                    graph.getNodes().filter(PhiNode.class).forEach(PhiNode::inferStamp);
                                    collectOptionFieldUsages(optionFieldUsages, optionDescriptorsType, method, graph);
                                    checkGraph(verifiers, context, graph);
                                } catch (VerificationError e) {
                                    errors.add(e.getMessage());
                                } catch (LinkageError e) {
                                // suppress linkages errors resulting from eager resolution
                                } catch (BailoutException e) {
                                // Graal bail outs on certain patterns in Java bytecode
                                // (e.g.,
                                // unbalanced monitors introduced by jacoco).
                                } catch (Throwable e) {
                                    try {
                                        tool.handleParsingException(e);
                                    } catch (Throwable t) {
                                        errors.add(String.format("Error while checking %s:%n%s", methodName, printStackTraceToString(e)));
                                    }
                                }
                            }
                        });
                    }
                }
            }
        }
        executor.shutdown();
        try {
            executor.awaitTermination(1, TimeUnit.HOURS);
        } catch (InterruptedException e1) {
            throw new RuntimeException(e1);
        }
        if (tool.shouldVerifyFoldableMethods()) {
            try {
                foldableMethodsVerifier.finish();
            } catch (Throwable e) {
                errors.add(e.getMessage());
            }
        }
    }
    checkOptionFieldUsages(errors, optionFieldUsages);
    if (!errors.isEmpty()) {
        StringBuilder msg = new StringBuilder();
        String nl = String.format("%n");
        for (String e : errors) {
            if (msg.length() != 0) {
                msg.append(nl);
            }
            msg.append(e);
        }
        Assert.fail(msg.toString());
    }
}

Example 17 with CoreProviders

use of org.graalvm.compiler.nodes.spi.CoreProviders in project graal by oracle.

the class SubstrateGraphBuilderPlugins method processFieldOffset.

private static boolean processFieldOffset(GraphBuilderContext b, Field targetField, ParsingReason reason, MetaAccessProvider metaAccess, boolean isSunMiscUnsafe) {
    if (!isValidField(targetField, isSunMiscUnsafe)) {
        return false;
    }
    if (SubstrateOptions.parseOnce() || reason == ParsingReason.PointsToAnalysis) {
        /* Register the field for unsafe access. */
        registerAsUnsafeAccessed(metaAccess, targetField);
    } else {
        HostedMetaAccess hostedMetaAccess = (HostedMetaAccess) metaAccess;
        HostedField hostedField = hostedMetaAccess.lookupJavaField(targetField);
        if (!hostedField.wrapped.isUnsafeAccessed()) {
            /*
                 * The target field was not constant folded during static analysis, so the above
                 * unsafe access registration did not run. A UnsupportedFeatureError will be thrown
                 * at run time for this call.
                 */
            return false;
        }
    }
    /* Usage of lambdas is not allowed in Graal nodes, so need explicit inner class. */
    Function<CoreProviders, JavaConstant> fieldOffsetConstantProvider = new Function<>() {

        @Override
        public JavaConstant apply(CoreProviders providers) {
            ResolvedJavaField rField = providers.getMetaAccess().lookupJavaField(targetField);
            if (rField instanceof SharedField) {
                long fieldOffset = ((SharedField) rField).getLocation();
                assert fieldOffset > 0;
                return JavaConstant.forLong(fieldOffset);
            }
            return null;
        }
    };
    b.addPush(JavaKind.Long, LazyConstantNode.create(StampFactory.forKind(JavaKind.Long), fieldOffsetConstantProvider, b));
    return true;
}

Example 18 with CoreProviders

use of org.graalvm.compiler.nodes.spi.CoreProviders in project graal by oracle.

the class AArch64HotSpotBackendFactory method createSuites.

@Override
protected HotSpotSuitesProvider createSuites(GraalHotSpotVMConfig config, HotSpotGraalRuntimeProvider runtime, CompilerConfiguration compilerConfiguration, Plugins plugins, HotSpotRegistersProvider registers, HotSpotReplacementsImpl replacements, OptionValues options) {
    AArch64SuitesCreator suitesCreator = new AArch64SuitesCreator(compilerConfiguration, plugins, Arrays.asList(SchedulePhase.class));
    BasePhase<CoreProviders> addressLoweringPhase = new AddressLoweringByUsePhase(new AArch64AddressLoweringByUse(new AArch64LIRKindTool(), true));
    return new AddressLoweringHotSpotSuitesProvider(suitesCreator, config, runtime, addressLoweringPhase);
}

Example 19 with CoreProviders

use of org.graalvm.compiler.nodes.spi.CoreProviders in project graal by oracle.

the class PoorMansEATest method test.

@SuppressWarnings("try")
private void test(final String snippet) {
    DebugContext debug = getDebugContext();
    try (DebugContext.Scope s = debug.scope("PoorMansEATest", new DebugDumpScope(snippet))) {
        StructuredGraph graph = parseEager(snippet, AllowAssumptions.NO);
        HighTierContext highTierContext = getDefaultHighTierContext();
        createInliningPhase().apply(graph, highTierContext);
        CoreProviders context = getProviders();
        new LoweringPhase(createCanonicalizerPhase(), LoweringTool.StandardLoweringStage.HIGH_TIER).apply(graph, context);
        // remove framestates in order to trigger the simplification.
        cleanup: for (FrameState fs : graph.getNodes(FrameState.TYPE).snapshot()) {
            for (Node input : fs.inputs()) {
                if (input instanceof NewInstanceNode) {
                    fs.replaceAtUsages(null);
                    fs.safeDelete();
                    continue cleanup;
                }
            }
        }
        createCanonicalizerPhase().apply(graph, context);
    } catch (Throwable e) {
        throw debug.handle(e);
    }
}

Example 20 with CoreProviders

use of org.graalvm.compiler.nodes.spi.CoreProviders in project graal by oracle.

the class LoopPhiCanonicalizerTest method test.

@Test
public void test() {
    StructuredGraph graph = parseEager("loopSnippet", AllowAssumptions.YES);
    NodePredicate loopPhis = node -> node instanceof PhiNode && ((PhiNode) node).merge() instanceof LoopBeginNode;
    CoreProviders context = getProviders();
    Assert.assertEquals(5, graph.getNodes().filter(loopPhis).count());
    createCanonicalizerPhase().apply(graph, context);
    Assert.assertEquals(2, graph.getNodes().filter(loopPhis).count());
    test("loopSnippet");
}