Search in sources :

Example 6 with UnsupportedFeatureException

use of com.oracle.graal.pointsto.constraints.UnsupportedFeatureException in project graal by oracle.

the class AnnotationSubstitutionProcessor method lookup.

@Override
public ResolvedJavaMethod lookup(ResolvedJavaMethod method) {
    Delete deleteAnnotation = deleteAnnotations.get(method);
    if (deleteAnnotation != null) {
        throw new UnsupportedFeatureException(deleteErrorMessage(method, deleteAnnotation, true));
    }
    ResolvedJavaMethod substitution = methodSubstitutions.get(method);
    if (substitution != null) {
        return substitution;
    }
    return method;
}
Also used : Delete(com.oracle.svm.core.annotate.Delete) UnsupportedFeatureException(com.oracle.graal.pointsto.constraints.UnsupportedFeatureException) ResolvedJavaMethod(jdk.vm.ci.meta.ResolvedJavaMethod)

Example 7 with UnsupportedFeatureException

use of com.oracle.graal.pointsto.constraints.UnsupportedFeatureException in project graal by oracle.

the class IntrinsifyMethodHandlesInvocationPlugin method processInvokeWithMethodHandle.

@SuppressWarnings("try")
private void processInvokeWithMethodHandle(GraphBuilderContext b, BytecodeProvider bytecodeProvider, ResolvedJavaMethod methodHandleMethod, ValueNode[] methodHandleArguments) {
    Plugins graphBuilderPlugins = new Plugins(((ReplacementsImpl) originalProviders.getReplacements()).getGraphBuilderPlugins());
    registerInvocationPlugins(graphBuilderPlugins.getInvocationPlugins(), bytecodeProvider);
    graphBuilderPlugins.prependParameterPlugin(new MethodHandlesParameterPlugin(methodHandleArguments));
    graphBuilderPlugins.clearInlineInvokePlugins();
    graphBuilderPlugins.prependInlineInvokePlugin(new MethodHandlesInlineInvokePlugin());
    graphBuilderPlugins.prependNodePlugin(new MethodHandlePlugin(originalProviders.getConstantReflection().getMethodHandleAccess(), false));
    /* We do all the word type rewriting because parameters to the lambda can be word types. */
    SnippetReflectionProvider originalSnippetReflection = GraalAccess.getOriginalSnippetReflection();
    WordOperationPlugin wordOperationPlugin = new WordOperationPlugin(originalSnippetReflection, new WordTypes(originalProviders.getMetaAccess(), FrameAccess.getWordKind()));
    graphBuilderPlugins.appendInlineInvokePlugin(wordOperationPlugin);
    graphBuilderPlugins.appendTypePlugin(wordOperationPlugin);
    graphBuilderPlugins.appendTypePlugin(new TrustedInterfaceTypePlugin());
    graphBuilderPlugins.appendNodePlugin(wordOperationPlugin);
    GraphBuilderConfiguration graphBuilderConfig = GraphBuilderConfiguration.getSnippetDefault(graphBuilderPlugins);
    GraphBuilderPhase.Instance graphBuilder = new GraphBuilderPhase.Instance(originalProviders.getMetaAccess(), originalProviders.getStampProvider(), originalProviders.getConstantReflection(), originalProviders.getConstantFieldProvider(), graphBuilderConfig, OptimisticOptimizations.NONE, null);
    DebugContext debug = b.getDebug();
    StructuredGraph graph = new StructuredGraph.Builder(b.getOptions(), debug).method(toOriginal(methodHandleMethod)).build();
    try (DebugContext.Scope s = debug.scope("IntrinsifyMethodHandles", graph)) {
        graphBuilder.apply(graph);
        /*
             * We do not care about the improved type information from Pi nodes, so we just delete
             * them to simplify our graph.
             */
        for (PiNode pi : graph.getNodes(PiNode.TYPE)) {
            pi.replaceAndDelete(pi.object());
        }
        /*
             * Support for MethodHandle that adapt the input type to a more generic type, i.e., a
             * MethodHandle that does a dynamic type check on a parameter.
             */
        for (UnaryOpLogicNode node : graph.getNodes().filter(UnaryOpLogicNode.class).filter(v -> v instanceof IsNullNode || v instanceof InstanceOfNode)) {
            ValueNode value = node.getValue();
            if (value instanceof ParameterNode) {
                /*
                     * We just assume that the InstanceOfNode or IsNullNode are used in an If and
                     * the true-successor is actually the branch we want. If that assumption is
                     * wrong, nothing bad happens - we will just continue to report the invocation
                     * as unsupported because the updated stamp for the parameter will not simplify
                     * the graph.
                     */
                if (node instanceof InstanceOfNode) {
                    InstanceOfNode inst = (InstanceOfNode) node;
                    TypeReference typeRef = inst.type();
                    value.setStamp(new ObjectStamp(typeRef.getType(), typeRef.isExact(), !inst.allowsNull(), false));
                } else {
                    assert node instanceof IsNullNode;
                    ResolvedJavaType type = value.stamp(NodeView.DEFAULT).javaType(originalProviders.getMetaAccess());
                    value.setStamp(new ObjectStamp(type, false, /* non-null */
                    true, false));
                }
            }
        }
        /*
             * The canonicalizer converts unsafe field accesses for get/set method handles back to
             * high-level field load and store nodes.
             */
        new CanonicalizerPhase().apply(graph, new PhaseContext(originalProviders));
        for (FixedGuardNode guard : graph.getNodes(FixedGuardNode.TYPE)) {
            if (guard.next() instanceof AccessFieldNode && guard.condition() instanceof IsNullNode && guard.isNegated() && ((IsNullNode) guard.condition()).getValue() == ((AccessFieldNode) guard.next()).object()) {
                /*
                     * Method handles to load and stores fields have null checks. Remove them, since
                     * the null check is implicitly done by the field access.
                     */
                GraphUtil.removeFixedWithUnusedInputs(guard);
            }
        }
        debug.dump(DebugContext.VERY_DETAILED_LEVEL, graph, "Final intrinisfication graph");
        /*
             * After parsing (and recursive inlining during parsing), the graph must contain only
             * one invocation (and therefore only one MethodCallTargetNode), plus the parameters,
             * constants, start, and return nodes.
             */
        Node singleFunctionality = null;
        ReturnNode singleReturn = null;
        for (Node node : graph.getNodes()) {
            if (node == graph.start() || node instanceof ParameterNode || node instanceof ConstantNode || node instanceof FrameState) {
                /* Ignore the allowed framework around the nodes we care about. */
                continue;
            } else if (node instanceof Invoke) {
                /* We check the MethodCallTargetNode, so we can ignore the invoke. */
                continue;
            } else if ((node instanceof MethodCallTargetNode || node instanceof LoadFieldNode || node instanceof StoreFieldNode) && singleFunctionality == null) {
                singleFunctionality = node;
                continue;
            } else if (node instanceof ReturnNode && singleReturn == null) {
                singleReturn = (ReturnNode) node;
                continue;
            }
            throw new UnsupportedFeatureException("Invoke with MethodHandle argument could not be reduced to at most a single call: " + methodHandleMethod.format("%H.%n(%p)"));
        }
        if (singleFunctionality instanceof MethodCallTargetNode) {
            MethodCallTargetNode singleCallTarget = (MethodCallTargetNode) singleFunctionality;
            assert singleReturn.result() == null || singleReturn.result() == singleCallTarget.invoke();
            /*
                 * Replace the originalTarget with the replacementTarget. Note that the
                 * replacementTarget node belongs to a different graph than originalTarget, so we
                 * need to match parameter back to the original graph and allocate a new
                 * MethodCallTargetNode for the original graph.
                 */
            ValueNode[] replacedArguments = new ValueNode[singleCallTarget.arguments().size()];
            for (int i = 0; i < replacedArguments.length; i++) {
                replacedArguments[i] = lookup(b, methodHandleArguments, singleCallTarget.arguments().get(i));
            }
            b.handleReplacedInvoke(singleCallTarget.invokeKind(), lookup(singleCallTarget.targetMethod()), replacedArguments, false);
        } else if (singleFunctionality instanceof LoadFieldNode) {
            LoadFieldNode fieldLoad = (LoadFieldNode) singleFunctionality;
            b.addPush(b.getInvokeReturnType().getJavaKind(), LoadFieldNode.create(null, lookup(b, methodHandleArguments, fieldLoad.object()), lookup(fieldLoad.field())));
        } else if (singleFunctionality instanceof StoreFieldNode) {
            StoreFieldNode fieldStore = (StoreFieldNode) singleFunctionality;
            b.add(new StoreFieldNode(lookup(b, methodHandleArguments, fieldStore.object()), lookup(fieldStore.field()), lookup(b, methodHandleArguments, fieldStore.value())));
        } else if (singleReturn.result() != null) {
            /* Replace the invocation with he constant result. */
            JavaConstant constantResult = singleReturn.result().asJavaConstant();
            assert b.getInvokeReturnType().getJavaKind() == constantResult.getJavaKind();
            b.addPush(constantResult.getJavaKind(), ConstantNode.forConstant(lookup(constantResult), universeProviders.getMetaAccess()));
        } else {
            /* No invoke and no return value, so nothing to do. */
            assert b.getInvokeReturnType().getJavaKind() == JavaKind.Void;
        }
    } catch (Throwable ex) {
        throw debug.handle(ex);
    }
}
Also used : ObjectStamp(org.graalvm.compiler.core.common.type.ObjectStamp) MethodCallTargetNode(org.graalvm.compiler.nodes.java.MethodCallTargetNode) AccessFieldNode(org.graalvm.compiler.nodes.java.AccessFieldNode) ReturnNode(org.graalvm.compiler.nodes.ReturnNode) FixedGuardNode(org.graalvm.compiler.nodes.FixedGuardNode) PiNode(org.graalvm.compiler.nodes.PiNode) UnaryOpLogicNode(org.graalvm.compiler.nodes.UnaryOpLogicNode) ValueNode(org.graalvm.compiler.nodes.ValueNode) IsNullNode(org.graalvm.compiler.nodes.calc.IsNullNode) FloatingNode(org.graalvm.compiler.nodes.calc.FloatingNode) LoadFieldNode(org.graalvm.compiler.nodes.java.LoadFieldNode) ConstantNode(org.graalvm.compiler.nodes.ConstantNode) InstanceOfNode(org.graalvm.compiler.nodes.java.InstanceOfNode) ParameterNode(org.graalvm.compiler.nodes.ParameterNode) StoreFieldNode(org.graalvm.compiler.nodes.java.StoreFieldNode) Node(org.graalvm.compiler.graph.Node) WordTypes(org.graalvm.compiler.word.WordTypes) JavaConstant(jdk.vm.ci.meta.JavaConstant) PiNode(org.graalvm.compiler.nodes.PiNode) FrameState(org.graalvm.compiler.nodes.FrameState) UnaryOpLogicNode(org.graalvm.compiler.nodes.UnaryOpLogicNode) ResolvedJavaType(jdk.vm.ci.meta.ResolvedJavaType) Invoke(org.graalvm.compiler.nodes.Invoke) PhaseContext(org.graalvm.compiler.phases.tiers.PhaseContext) SnippetReflectionProvider(org.graalvm.compiler.api.replacements.SnippetReflectionProvider) ConstantNode(org.graalvm.compiler.nodes.ConstantNode) StructuredGraph(org.graalvm.compiler.nodes.StructuredGraph) ParameterNode(org.graalvm.compiler.nodes.ParameterNode) TypeReference(org.graalvm.compiler.core.common.type.TypeReference) GraphBuilderPhase(org.graalvm.compiler.java.GraphBuilderPhase) InvocationPlugins(org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugins) Plugins(org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration.Plugins) StoreFieldNode(org.graalvm.compiler.nodes.java.StoreFieldNode) UnsupportedFeatureException(com.oracle.graal.pointsto.constraints.UnsupportedFeatureException) GraphBuilderConfiguration(org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration) DebugContext(org.graalvm.compiler.debug.DebugContext) LoadFieldNode(org.graalvm.compiler.nodes.java.LoadFieldNode) TrustedInterfaceTypePlugin(com.oracle.svm.core.graal.phases.TrustedInterfaceTypePlugin) FixedGuardNode(org.graalvm.compiler.nodes.FixedGuardNode) ReturnNode(org.graalvm.compiler.nodes.ReturnNode) MethodCallTargetNode(org.graalvm.compiler.nodes.java.MethodCallTargetNode) IsNullNode(org.graalvm.compiler.nodes.calc.IsNullNode) AccessFieldNode(org.graalvm.compiler.nodes.java.AccessFieldNode) ValueNode(org.graalvm.compiler.nodes.ValueNode) CanonicalizerPhase(org.graalvm.compiler.phases.common.CanonicalizerPhase) InstanceOfNode(org.graalvm.compiler.nodes.java.InstanceOfNode) MethodHandlePlugin(org.graalvm.compiler.replacements.MethodHandlePlugin) WordOperationPlugin(org.graalvm.compiler.word.WordOperationPlugin)

Example 8 with UnsupportedFeatureException

use of com.oracle.graal.pointsto.constraints.UnsupportedFeatureException in project graal by oracle.

the class AnalysisUniverse method createType.

@SuppressFBWarnings(value = { "ES_COMPARING_STRINGS_WITH_EQ" }, justification = "Bug in findbugs")
private AnalysisType createType(ResolvedJavaType type, ResolvedJavaType hostType) {
    if (!hostVM.platformSupported(type)) {
        throw new UnsupportedFeatureException("type is not available in this platform: " + type.toJavaName(true));
    }
    if (sealed && !type.isArray()) {
        /*
             * We allow new array classes to be created at any time, since they do not affect the
             * closed world analysis.
             */
        throw AnalysisError.typeNotFound(type);
    }
    if (!type.isArray() && !type.isPrimitive()) {
        type.initialize();
    }
    /*
         * We do not want multiple threads to create the AnalysisType simultaneously, because we
         * want a unique id number per type. So claim the type first, and only when the claim
         * succeeds create the AnalysisType.
         */
    Object claim = Thread.currentThread().getName();
    retry: while (true) {
        Object result = types.putIfAbsent(type, claim);
        if (result instanceof AnalysisType) {
            return (AnalysisType) result;
        } else if (result != null) {
            /*
                 * Another thread installed a claim, wait until that thread publishes the
                 * AnalysisType.
                 */
            do {
                result = types.get(type);
                if (result == null) {
                    /*
                         * The other thread gave up, probably because of an exception. Re-try to
                         * create the type ourself. Probably we are going to fail and throw an
                         * exception too, but that is OK.
                         */
                    continue retry;
                } else if (result == claim) {
                    /*
                         * We are waiting for a type that we have claimed ourselves => deadlock.
                         */
                    throw JVMCIError.shouldNotReachHere("Deadlock creating new types");
                }
            } while (!(result instanceof AnalysisType));
            return (AnalysisType) result;
        } else {
            break retry;
        }
    }
    try {
        JavaKind storageKind = getStorageKind(type, originalMetaAccess, getTarget());
        AnalysisType newValue = new AnalysisType(this, type, storageKind, objectClass);
        hostVM.registerType(newValue, hostType);
        synchronized (this) {
            /*
                 * Synchronize modifications of typesById, so that we do not lose array stores in
                 * one thread that run concurrently with Arrays.copyOf in another thread. This is
                 * the only code that writes to typesById. Reads from typesById in other parts do
                 * not need synchronization because typesById is a volatile field, i.e., reads
                 * always pick up the latest and longest array; and we never publish a type before
                 * it is registered in typesById, i.e., before the array has the appropriate length.
                 */
            if (newValue.getId() >= typesById.length) {
                typesById = Arrays.copyOf(typesById, typesById.length * 2);
            }
            assert typesById[newValue.getId()] == null;
            typesById[newValue.getId()] = newValue;
            if (newValue.isJavaLangObject()) {
                assert objectClass == null;
                objectClass = newValue;
            }
        }
        /*
             * Now that our type is correctly registered in the id-to-type array, make it accessible
             * by other threads.
             */
        Object oldValue = types.put(type, newValue);
        assert oldValue == claim;
        claim = null;
        ResolvedJavaType enclosingType = newValue.getWrapped().getEnclosingType();
        /* If not being currently constructed by this thread. */
        if (enclosingType != null && !types.containsKey(enclosingType)) {
            /* Make sure that the enclosing type is also in the universe. */
            newValue.getEnclosingType();
        }
        return newValue;
    } finally {
        /* In case of any exception, remove the claim so that we do not deadlock. */
        if (claim != null) {
            types.remove(type, claim);
        }
    }
}
Also used : UnsupportedFeatureException(com.oracle.graal.pointsto.constraints.UnsupportedFeatureException) ResolvedJavaType(jdk.vm.ci.meta.ResolvedJavaType) JavaKind(jdk.vm.ci.meta.JavaKind) SuppressFBWarnings(org.graalvm.compiler.core.common.SuppressFBWarnings)

Example 9 with UnsupportedFeatureException

use of com.oracle.graal.pointsto.constraints.UnsupportedFeatureException in project graal by oracle.

the class NativeImageGenerator method doRun.

@SuppressWarnings("try")
private void doRun(Map<Method, CEntryPointData> entryPoints, Method mainEntryPoint, JavaMainSupport javaMainSupport, String imageName, AbstractBootImage.NativeImageKind k, SubstitutionProcessor harnessSubstitutions, ForkJoinPool compilationExecutor, ForkJoinPool analysisExecutor) {
    List<HostedMethod> hostedEntryPoints = new ArrayList<>();
    NativeLibraries nativeLibs;
    SVMHost svmHost;
    AnalysisMetaAccess aMetaAccess;
    SnippetReflectionProvider aSnippetReflection;
    HostedProviders aProviders;
    Throwable error = null;
    OptionValues options = HostedOptionValues.singleton();
    SnippetReflectionProvider originalSnippetReflection = GraalAccess.getOriginalSnippetReflection();
    try (DebugContext debug = DebugContext.create(options, new GraalDebugHandlersFactory(originalSnippetReflection))) {
        try (Indent indent = debug.logAndIndent("start analysis pass")) {
            try (StopTimer t = new Timer("setup").start()) {
                // TODO Make customizable via command line parameter.
                Platform platform = defaultPlatform();
                TargetDescription target = createTarget(platform);
                OSInterface osInterface = createOSInterface(loader);
                ObjectLayout objectLayout = new ObjectLayout(target, SubstrateAMD64Backend.getDeoptScatchSpace());
                CompressEncoding compressEncoding = new CompressEncoding(SubstrateOptions.UseHeapBaseRegister.getValue() ? 1 : 0, 0);
                ImageSingletons.add(Platform.class, platform);
                ImageSingletons.add(TargetDescription.class, target);
                ImageSingletons.add(OSInterface.class, osInterface);
                ImageSingletons.add(ObjectLayout.class, objectLayout);
                ImageSingletons.add(CompressEncoding.class, compressEncoding);
                if (javaMainSupport != null) {
                    ImageSingletons.add(JavaMainSupport.class, javaMainSupport);
                }
                Providers originalProviders = GraalAccess.getOriginalProviders();
                MetaAccessProvider originalMetaAccess = originalProviders.getMetaAccess();
                AnalysisPolicy analysisPolicy;
                if (PointstoOptions.AllocationSiteSensitiveHeap.getValue(options)) {
                    // context sensitive analysis
                    analysisPolicy = new SVMBytecodeAnalysisPolicy(options);
                } else {
                    // context insensitive analysis
                    analysisPolicy = new SVMDefaultAnalysisPolicy(options);
                }
                svmHost = new SVMHost(options, platform, analysisPolicy, loader.getClassLoader());
                featureHandler.registerFeatures(loader);
                AfterRegistrationAccessImpl access = new AfterRegistrationAccessImpl(featureHandler, loader, originalMetaAccess);
                featureHandler.forEachFeature(feature -> feature.afterRegistration(access));
                registerEntryPoints(entryPoints);
                /*
                     * Check if any configuration factory class was registered. If not, register the
                     * basic one.
                     */
                HostedConfiguration.setDefaultIfEmpty();
                GraalConfiguration.setDefaultIfEmpty();
                registerEntryPoints(entryPoints);
                CFunctionSubstitutionProcessor cfunctionSubstitutions = new CFunctionSubstitutionProcessor();
                AnnotationSubstitutionProcessor annotationSubstitutions = new DeclarativeSubstitutionProcessor(loader, originalMetaAccess);
                ImageSingletons.add(AnnotationSubstitutionProcessor.class, annotationSubstitutions);
                annotationSubstitutions.init();
                UnsafeAutomaticSubstitutionProcessor automaticSubstitutions = new UnsafeAutomaticSubstitutionProcessor(annotationSubstitutions);
                ImageSingletons.add(UnsafeAutomaticSubstitutionProcessor.class, automaticSubstitutions);
                automaticSubstitutions.init(originalMetaAccess);
                SubstitutionProcessor substitutions = SubstitutionProcessor.chainUpInOrder(harnessSubstitutions, new AnnotationSupport(originalMetaAccess, originalSnippetReflection), annotationSubstitutions, cfunctionSubstitutions, automaticSubstitutions);
                aUniverse = new AnalysisUniverse(svmHost, target, substitutions, originalMetaAccess, originalSnippetReflection, new SubstrateSnippetReflectionProvider());
                aMetaAccess = new AnalysisMetaAccess(aUniverse, originalMetaAccess);
                // native libraries
                AnalysisConstantReflectionProvider aConstantReflection = new AnalysisConstantReflectionProvider(svmHost, aUniverse, originalProviders.getConstantReflection());
                AnalysisConstantFieldProvider aConstantFieldProvider = new AnalysisConstantFieldProvider(aUniverse, aMetaAccess);
                aSnippetReflection = new HostedSnippetReflectionProvider(svmHost);
                nativeLibs = processNativeLibraryImports(aMetaAccess, aConstantReflection, aSnippetReflection);
                /*
                     * Install all snippets so that the types, methods, and fields used in the
                     * snippets get added to the universe.
                     */
                ForeignCallsProvider aForeignCalls = new SubstrateForeignCallsProvider();
                LoweringProvider aLoweringProvider = SubstrateLoweringProvider.create(aMetaAccess, null);
                StampProvider aStampProvider = new SubstrateStampProvider(aMetaAccess);
                WordTypes aWordTypes = new WordTypes(aMetaAccess, FrameAccess.getWordKind());
                aProviders = new HostedProviders(aMetaAccess, null, aConstantReflection, aConstantFieldProvider, aForeignCalls, aLoweringProvider, null, aStampProvider, aSnippetReflection, aWordTypes);
                BytecodeProvider bytecodeProvider = new ResolvedJavaMethodBytecodeProvider();
                SubstrateReplacements aReplacements = new SubstrateReplacements(options, aProviders, aSnippetReflection, bytecodeProvider, target, new SubstrateGraphMakerFactory(aWordTypes));
                aProviders = new HostedProviders(aMetaAccess, null, aConstantReflection, aConstantFieldProvider, aForeignCalls, aLoweringProvider, aReplacements, aStampProvider, aSnippetReflection, aWordTypes);
                bigbang = new Inflation(options, aUniverse, aProviders, svmHost, analysisExecutor);
                /*
                     * Eagerly register all target fields of recomputed value fields as unsafe
                     * accessed.
                     */
                annotationSubstitutions.processComputedValueFields(bigbang);
                try (Indent indent2 = debug.logAndIndent("process startup initializers")) {
                    DuringSetupAccessImpl config = new DuringSetupAccessImpl(featureHandler, loader, bigbang, svmHost);
                    featureHandler.forEachFeature(feature -> feature.duringSetup(config));
                }
                NativeImageGenerator.registerGraphBuilderPlugins(featureHandler, null, aProviders, aMetaAccess, aUniverse, null, null, nativeLibs, loader, true, true);
                registerReplacements(debug, featureHandler, null, aProviders, aProviders.getSnippetReflection(), true);
                /*
                     * Install feature supported substitutions.
                     */
                SubstitutionProcessor[] featureNativeSubstitutions = aUniverse.getFeatureNativeSubstitutions();
                if (featureNativeSubstitutions.length > 0) {
                    SubstitutionProcessor chain = SubstitutionProcessor.chainUpInOrder(featureNativeSubstitutions);
                    SubstitutionProcessor nativeSubstitutionProcessor = new NativeMethodSubstitutionProcessor(chain, aReplacements);
                    SubstitutionProcessor.extendsTheChain(substitutions, new SubstitutionProcessor[] { nativeSubstitutionProcessor });
                }
                SubstitutionProcessor.extendsTheChain(substitutions, aUniverse.getFeatureSubstitutions());
                /*
                     * System classes and fields are necessary to tell the static analysis that
                     * certain things really "exist". The most common reason for that is that there
                     * are no instances and allocations of these classes seen during the static
                     * analysis. The heap chunks are one good example.
                     */
                try (Indent indent2 = debug.logAndIndent("add initial classes/fields/methods")) {
                    bigbang.addSystemClass(Object.class, false, false).registerAsInHeap();
                    bigbang.addSystemField(DynamicHub.class, "vtable");
                    bigbang.addSystemClass(String.class, false, false).registerAsInHeap();
                    bigbang.addSystemClass(String[].class, false, false).registerAsInHeap();
                    bigbang.addSystemField(String.class, "value").registerAsInHeap();
                    bigbang.addSystemClass(long[].class, false, false).registerAsInHeap();
                    bigbang.addSystemClass(byte[].class, false, false).registerAsInHeap();
                    bigbang.addSystemClass(byte[][].class, false, false).registerAsInHeap();
                    bigbang.addSystemClass(Object[].class, false, false).registerAsInHeap();
                    bigbang.addSystemClass(CFunctionPointer[].class, false, false).registerAsInHeap();
                    bigbang.addSystemClass(PointerBase[].class, false, false).registerAsInHeap();
                    // Fields of BootImageInfo that get patched via relocation to addresses
                    // to the partitions of the native image heap.
                    bigbang.addSystemStaticField(NativeImageInfo.class, "firstReadOnlyPrimitiveObject").registerAsInHeap();
                    bigbang.addSystemStaticField(NativeImageInfo.class, "lastReadOnlyPrimitiveObject").registerAsInHeap();
                    bigbang.addSystemStaticField(NativeImageInfo.class, "firstReadOnlyReferenceObject").registerAsInHeap();
                    bigbang.addSystemStaticField(NativeImageInfo.class, "lastReadOnlyReferenceObject").registerAsInHeap();
                    bigbang.addSystemStaticField(NativeImageInfo.class, "firstWritablePrimitiveObject").registerAsInHeap();
                    bigbang.addSystemStaticField(NativeImageInfo.class, "lastWritablePrimitiveObject").registerAsInHeap();
                    bigbang.addSystemStaticField(NativeImageInfo.class, "firstWritableReferenceObject").registerAsInHeap();
                    bigbang.addSystemStaticField(NativeImageInfo.class, "lastWritableReferenceObject").registerAsInHeap();
                    // Graal uses it for type checks in the partial escape analysis phase.
                    bigbang.addSystemClass(Reference.class, false, false);
                    bigbang.addSystemClass(AllocationSite.class, false, false).registerAsInHeap();
                    bigbang.addSystemClass(AllocationCounter.class, false, false).registerAsInHeap();
                    bigbang.addSystemClass(AtomicReference.class, false, false).registerAsInHeap();
                    try {
                        /*
                             * TODO we want to get rid of these explicit registrations. All
                             * registered foreign calls should automatically be included in the
                             * static analysis.
                             */
                        bigbang.addRootMethod(ArraycopySnippets.class.getDeclaredMethod("doArraycopy", Object.class, int.class, Object.class, int.class, int.class));
                        bigbang.addRootMethod(Object.class.getDeclaredMethod("getClass"));
                        if (NativeImageOptions.DeoptimizeAll.getValue()) {
                            bigbang.addRootMethod(DeoptTester.class.getMethod("deoptTest"));
                        }
                    } catch (NoSuchMethodException ex) {
                        throw VMError.shouldNotReachHere(ex);
                    }
                    for (JavaKind kind : JavaKind.values()) {
                        if (kind.isPrimitive() && kind != JavaKind.Void) {
                            bigbang.addSystemClass(kind.toJavaClass(), false, true);
                            bigbang.addSystemField(kind.toBoxedJavaClass(), "value");
                            bigbang.addSystemMethod(kind.toBoxedJavaClass(), "valueOf", kind.toJavaClass());
                            bigbang.addSystemMethod(kind.toBoxedJavaClass(), kind.getJavaName() + "Value");
                        }
                    }
                    entryPoints.forEach((method, entryPointData) -> CEntryPointCallStubSupport.singleton().registerStubForMethod(method, () -> entryPointData));
                    for (StructuredGraph graph : aReplacements.getSnippetGraphs(GraalOptions.TrackNodeSourcePosition.getValue(options))) {
                        MethodTypeFlowBuilder.registerUsedElements(bigbang, graph, null);
                    }
                }
                try (Indent indent2 = debug.logAndIndent("process analysis initializers")) {
                    BeforeAnalysisAccessImpl config = new BeforeAnalysisAccessImpl(featureHandler, loader, bigbang, svmHost, nativeLibs);
                    featureHandler.forEachFeature(feature -> feature.beforeAnalysis(config));
                }
            }
            try (StopTimer t = new Timer("analysis").start()) {
                Timer processFeaturesTimer = new Timer("(features)", false);
                /*
                     * Iterate until analysis reaches a fixpoint
                     */
                DuringAnalysisAccessImpl config = new DuringAnalysisAccessImpl(featureHandler, loader, bigbang, svmHost, nativeLibs);
                int numIterations = 0;
                while (true) {
                    try (Indent indent2 = debug.logAndIndent("new analysis iteration")) {
                        /*
                             * Do the analysis (which itself is done in a similar iterative process)
                             */
                        boolean analysisChanged = bigbang.finish();
                        numIterations++;
                        if (numIterations > 1000) {
                            /*
                                 * Usually there are < 10 iterations. If we have so many iterations,
                                 * we probably have an endless loop (but at least we have a
                                 * performance problem because we re-start the analysis so often).
                                 */
                            throw VMError.shouldNotReachHere("Static analysis did not reach a fix point after " + numIterations + " iterations because a Feature keeps requesting new analysis iterations. The analysis itself " + (analysisChanged ? "DID" : "DID NOT") + " find a change in type states in the last iteration.");
                        }
                        /*
                             * Allow features to change the universe
                             */
                        try (StopTimer t2 = processFeaturesTimer.start()) {
                            int numTypes = aUniverse.getTypes().size();
                            int numMethods = aUniverse.getMethods().size();
                            int numFields = aUniverse.getFields().size();
                            featureHandler.forEachFeature(feature -> feature.duringAnalysis(config));
                            if (!config.getAndResetRequireAnalysisIteration()) {
                                if (numTypes != aUniverse.getTypes().size() || numMethods != aUniverse.getMethods().size() || numFields != aUniverse.getFields().size()) {
                                    throw UserError.abort("When a feature makes more types, methods, of fields reachable, it must require another analysis iteration via DuringAnalysisAccess.requireAnalysisIteration()");
                                }
                                break;
                            }
                        }
                    }
                }
                AfterAnalysisAccessImpl postConfig = new AfterAnalysisAccessImpl(featureHandler, loader, bigbang);
                featureHandler.forEachFeature(feature -> feature.afterAnalysis(postConfig));
                checkUniverse();
                bigbang.typeFlowTimer.print();
                bigbang.checkObjectsTimer.print();
                processFeaturesTimer.print();
                /* report the unsupported features by throwing UnsupportedFeatureException */
                bigbang.getUnsupportedFeatures().report(bigbang);
            } catch (UnsupportedFeatureException ufe) {
                if (NativeImageOptions.ReportUnsupportedFeaturesCause.getValue() && ufe.getCause() != null) {
                    System.err.println("Original exception: ");
                    ufe.getCause().printStackTrace();
                }
                throw UserError.abort(ufe.getMessage());
            }
        } catch (InterruptedException ie) {
            throw new InterruptImageBuilding();
        } catch (RuntimeException | Error e) {
            // Prevents swallowing exceptions when ReturnAfterAnalysis is true
            error = e;
            throw e;
        } finally {
            OnAnalysisExitAccess onExitConfig = new OnAnalysisExitAccessImpl(featureHandler, loader, bigbang);
            featureHandler.forEachFeature(feature -> {
                try {
                    feature.onAnalysisExit(onExitConfig);
                } catch (Exception ex) {
                    System.err.println("Exception during " + feature.getClass().getName() + ".onAnalysisExit()");
                }
            });
            if (AnalysisReportsOptions.PrintAnalysisCallTree.getValue(options)) {
                String reportName = imageName.substring(imageName.lastIndexOf("/") + 1);
                CallTreePrinter.print(bigbang, SubstrateOptions.Path.getValue(), reportName);
            }
            if (AnalysisReportsOptions.PrintImageObjectTree.getValue(options)) {
                String reportName = imageName.substring(imageName.lastIndexOf("/") + 1);
                ObjectTreePrinter.print(bigbang, SubstrateOptions.Path.getValue(), reportName);
            }
            if (PointstoOptions.ReportAnalysisStatistics.getValue(options)) {
                PointsToStats.report(bigbang, imageName.replace("images/", ""));
            }
            if (PointstoOptions.PrintSynchronizedAnalysis.getValue(options)) {
                TypeState allSynchronizedTypeState = bigbang.getAllSynchronizedTypeState();
                String typesString = // 
                allSynchronizedTypeState.closeToAllInstantiated(bigbang) ? // 
                "close to all instantiated" : StreamSupport.stream(allSynchronizedTypeState.types().spliterator(), false).map(AnalysisType::getName).collect(Collectors.joining(", "));
                System.out.println();
                System.out.println("AllSynchronizedTypes");
                System.out.println("Synchronized types #: " + allSynchronizedTypeState.typesCount());
                System.out.println("Types: " + typesString);
                System.out.println();
            }
        }
        if (error == null && NativeImageOptions.ReturnAfterAnalysis.getValue()) {
            return;
        }
        if (NativeImageOptions.ExitAfterAnalysis.getValue()) {
            throw new InterruptImageBuilding("interrupted image construction as ExitAfterAnalysis is set");
        }
        NativeImageHeap heap;
        HostedMethod mainEntryPointHostedStub;
        HostedMetaAccess hMetaAccess;
        SharedRuntimeConfigurationBuilder runtime;
        try (StopTimer t = new Timer("universe").start()) {
            hUniverse = new HostedUniverse(bigbang, svmHost);
            hMetaAccess = new HostedMetaAccess(hUniverse, aMetaAccess);
            new UniverseBuilder(aUniverse, aMetaAccess, hUniverse, hMetaAccess, HostedConfiguration.instance().createStaticAnalysisResultsBuilder(bigbang, hUniverse), bigbang.getUnsupportedFeatures()).build(debug);
            runtime = new HostedRuntimeConfigurationBuilder(options, svmHost, hUniverse, hMetaAccess, aProviders).build();
            registerGraphBuilderPlugins(featureHandler, runtime.getRuntimeConfig(), (HostedProviders) runtime.getRuntimeConfig().getProviders(), aMetaAccess, aUniverse, hMetaAccess, hUniverse, nativeLibs, loader, false, true);
            if (NativeImageOptions.PrintUniverse.getValue()) {
                printTypes();
            }
            /* Find the entry point methods in the hosted world. */
            for (AnalysisMethod m : aUniverse.getMethods()) {
                if (m.isEntryPoint()) {
                    HostedMethod found = hUniverse.lookup(m);
                    assert found != null;
                    hostedEntryPoints.add(found);
                }
            }
            /* Find main entry point */
            if (mainEntryPoint != null) {
                AnalysisMethod analysisStub = CEntryPointCallStubSupport.singleton().getStubForMethod(mainEntryPoint);
                mainEntryPointHostedStub = (HostedMethod) hMetaAccess.getUniverse().lookup(analysisStub);
                assert hostedEntryPoints.contains(mainEntryPointHostedStub);
            } else {
                mainEntryPointHostedStub = null;
            }
            if (hostedEntryPoints.size() == 0) {
                throw UserError.abort("Warning: no entry points found, i.e., no method annotated with @" + CEntryPoint.class.getSimpleName());
            }
            heap = new NativeImageHeap(aUniverse, hUniverse, hMetaAccess);
            BeforeCompilationAccessImpl config = new BeforeCompilationAccessImpl(featureHandler, loader, aUniverse, hUniverse, hMetaAccess, heap);
            featureHandler.forEachFeature(feature -> feature.beforeCompilation(config));
            bigbang.getUnsupportedFeatures().report(bigbang);
        } catch (UnsupportedFeatureException ufe) {
            throw UserError.abort(ufe.getMessage());
        }
        recordMethodsWithStackValues();
        recordRestrictHeapAccessCallees(aUniverse.getMethods());
        /*
             * After this point, all TypeFlow (and therefore also TypeState) objects are unreachable
             * and can be garbage collected. This is important to keep the overall memory footprint
             * low. However, this also means we no longer have complete call chain information. Only
             * the summarized information stored in the StaticAnalysisResult objects is available
             * after this point.
             */
        bigbang.cleanupAfterAnalysis();
        NativeImageCodeCache codeCache;
        CompileQueue compileQueue;
        try (StopTimer t = new Timer("compile").start()) {
            compileQueue = HostedConfiguration.instance().createCompileQueue(debug, featureHandler, hUniverse, runtime, NativeImageOptions.DeoptimizeAll.getValue(), aSnippetReflection, compilationExecutor);
            compileQueue.finish(debug);
            /* release memory taken by graphs for the image writing */
            hUniverse.getMethods().forEach(HostedMethod::clear);
            codeCache = new NativeImageCodeCache(compileQueue.getCompilations(), heap);
            codeCache.layoutMethods(debug);
            codeCache.layoutConstants();
            AfterCompilationAccessImpl config = new AfterCompilationAccessImpl(featureHandler, loader, aUniverse, hUniverse, hMetaAccess, heap);
            featureHandler.forEachFeature(feature -> feature.afterCompilation(config));
        }
        try (Indent indent = debug.logAndIndent("create native image")) {
            try (DebugContext.Scope buildScope = debug.scope("CreateBootImage")) {
                try (StopTimer t = new Timer("image").start()) {
                    // Start building the model of the native image heap.
                    heap.addInitialObjects(debug);
                    // Then build the model of the code cache, which can
                    // add objects to the native image heap.
                    codeCache.addConstantsToHeap(debug);
                    // Finish building the model of the native image heap.
                    heap.addTrailingObjects(debug);
                    AfterHeapLayoutAccessImpl config = new AfterHeapLayoutAccessImpl(featureHandler, loader, hMetaAccess);
                    featureHandler.forEachFeature(feature -> feature.afterHeapLayout(config));
                    this.image = AbstractBootImage.create(k, hUniverse, hMetaAccess, nativeLibs, heap, codeCache, hostedEntryPoints, mainEntryPointHostedStub);
                    image.build(debug);
                    if (NativeImageOptions.PrintUniverse.getValue()) {
                        /*
                             * This debug output must be printed _after_ and not _during_ image
                             * building, because it adds some PrintStream objects to static fields,
                             * which disrupts the heap.
                             */
                        codeCache.printCompilationResults();
                    }
                }
            }
        }
        BeforeImageWriteAccessImpl beforeConfig = new BeforeImageWriteAccessImpl(featureHandler, loader, imageName, image, runtime.getRuntimeConfig(), aUniverse, hUniverse, optionProvider, hMetaAccess);
        featureHandler.forEachFeature(feature -> feature.beforeImageWrite(beforeConfig));
        try (StopTimer t = new Timer("write").start()) {
            /*
                 * This will write the debug info too -- i.e. we may be writing more than one file,
                 * if the debug info is in a separate file. We need to push writing the file to the
                 * image implementation, because whether the debug info and image share a file or
                 * not is an implementation detail of the image.
                 */
            Path tmpDir = tempDirectory();
            Path imagePath = image.write(debug, generatedFiles(HostedOptionValues.singleton()), tmpDir, imageName, beforeConfig);
            AfterImageWriteAccessImpl afterConfig = new AfterImageWriteAccessImpl(featureHandler, loader, imagePath, tmpDir, image.getBootImageKind());
            featureHandler.forEachFeature(feature -> feature.afterImageWrite(afterConfig));
        }
    }
}
Also used : UnsafeAutomaticSubstitutionProcessor(com.oracle.svm.hosted.substitute.UnsafeAutomaticSubstitutionProcessor) AnalysisConstantReflectionProvider(com.oracle.svm.hosted.ameta.AnalysisConstantReflectionProvider) Indent(org.graalvm.compiler.debug.Indent) AllocationCounter(com.oracle.svm.core.allocationprofile.AllocationCounter) OnAnalysisExitAccessImpl(com.oracle.svm.hosted.FeatureImpl.OnAnalysisExitAccessImpl) HostedOptionValues(com.oracle.svm.core.option.HostedOptionValues) RuntimeOptionValues(com.oracle.svm.core.option.RuntimeOptionValues) OptionValues(org.graalvm.compiler.options.OptionValues) Platform(org.graalvm.nativeimage.Platform) AfterCompilationAccessImpl(com.oracle.svm.hosted.FeatureImpl.AfterCompilationAccessImpl) ObjectLayout(com.oracle.svm.core.config.ObjectLayout) ArrayList(java.util.ArrayList) CompressEncoding(org.graalvm.compiler.core.common.CompressEncoding) WordTypes(org.graalvm.compiler.word.WordTypes) DeoptTester(com.oracle.svm.core.deopt.DeoptTester) HostedRuntimeConfigurationBuilder(com.oracle.svm.hosted.code.HostedRuntimeConfigurationBuilder) HostedProviders(com.oracle.graal.pointsto.meta.HostedProviders) HostedSnippetReflectionProvider(com.oracle.svm.hosted.meta.HostedSnippetReflectionProvider) OnAnalysisExitAccess(org.graalvm.nativeimage.Feature.OnAnalysisExitAccess) DuringSetupAccessImpl(com.oracle.svm.hosted.FeatureImpl.DuringSetupAccessImpl) ResolvedJavaMethodBytecodeProvider(org.graalvm.compiler.bytecode.ResolvedJavaMethodBytecodeProvider) BeforeAnalysisAccessImpl(com.oracle.svm.hosted.FeatureImpl.BeforeAnalysisAccessImpl) AnalysisConstantFieldProvider(com.oracle.svm.hosted.ameta.AnalysisConstantFieldProvider) UnsupportedFeatureException(com.oracle.graal.pointsto.constraints.UnsupportedFeatureException) BytecodeProvider(org.graalvm.compiler.bytecode.BytecodeProvider) ResolvedJavaMethodBytecodeProvider(org.graalvm.compiler.bytecode.ResolvedJavaMethodBytecodeProvider) DebugContext(org.graalvm.compiler.debug.DebugContext) NativeImageInfo(com.oracle.svm.core.heap.NativeImageInfo) HostedUniverse(com.oracle.svm.hosted.meta.HostedUniverse) GraalDebugHandlersFactory(org.graalvm.compiler.printer.GraalDebugHandlersFactory) UniverseBuilder(com.oracle.svm.hosted.meta.UniverseBuilder) SVMDefaultAnalysisPolicy(com.oracle.svm.hosted.analysis.SVMDefaultAnalysisPolicy) AnalysisMethod(com.oracle.graal.pointsto.meta.AnalysisMethod) SubstrateReplacements(com.oracle.svm.core.graal.meta.SubstrateReplacements) AfterAnalysisAccessImpl(com.oracle.svm.hosted.FeatureImpl.AfterAnalysisAccessImpl) HostedMethod(com.oracle.svm.hosted.meta.HostedMethod) StopTimer(com.oracle.graal.pointsto.util.Timer.StopTimer) AnalysisPolicy(com.oracle.graal.pointsto.AnalysisPolicy) SVMDefaultAnalysisPolicy(com.oracle.svm.hosted.analysis.SVMDefaultAnalysisPolicy) SVMBytecodeAnalysisPolicy(com.oracle.svm.hosted.analysis.SVMBytecodeAnalysisPolicy) DuringAnalysisAccessImpl(com.oracle.svm.hosted.FeatureImpl.DuringAnalysisAccessImpl) MetaAccessProvider(jdk.vm.ci.meta.MetaAccessProvider) SubstrateForeignCallsProvider(com.oracle.svm.core.graal.meta.SubstrateForeignCallsProvider) ForeignCallsProvider(org.graalvm.compiler.core.common.spi.ForeignCallsProvider) AnalysisType(com.oracle.graal.pointsto.meta.AnalysisType) AfterImageWriteAccessImpl(com.oracle.svm.hosted.FeatureImpl.AfterImageWriteAccessImpl) NativeLibraries(com.oracle.svm.hosted.c.NativeLibraries) BeforeImageWriteAccessImpl(com.oracle.svm.hosted.FeatureImpl.BeforeImageWriteAccessImpl) SubstrateTargetDescription(com.oracle.svm.core.graal.meta.SubstrateTargetDescription) TargetDescription(jdk.vm.ci.code.TargetDescription) AnnotationSupport(com.oracle.svm.hosted.annotation.AnnotationSupport) SubstrateForeignCallsProvider(com.oracle.svm.core.graal.meta.SubstrateForeignCallsProvider) SubstrateLoweringProvider(com.oracle.svm.core.graal.meta.SubstrateLoweringProvider) NodeLoweringProvider(com.oracle.svm.core.graal.snippets.NodeLoweringProvider) LoweringProvider(org.graalvm.compiler.nodes.spi.LoweringProvider) Providers(org.graalvm.compiler.phases.util.Providers) HostedProviders(com.oracle.graal.pointsto.meta.HostedProviders) SnippetReflectionProvider(org.graalvm.compiler.api.replacements.SnippetReflectionProvider) HostedSnippetReflectionProvider(com.oracle.svm.hosted.meta.HostedSnippetReflectionProvider) SubstrateSnippetReflectionProvider(com.oracle.svm.core.graal.meta.SubstrateSnippetReflectionProvider) Inflation(com.oracle.svm.hosted.analysis.Inflation) AfterRegistrationAccessImpl(com.oracle.svm.hosted.FeatureImpl.AfterRegistrationAccessImpl) StructuredGraph(org.graalvm.compiler.nodes.StructuredGraph) ArraycopySnippets(com.oracle.svm.core.graal.jdk.ArraycopySnippets) InterruptImageBuilding(com.oracle.svm.core.util.InterruptImageBuilding) AnalysisUniverse(com.oracle.graal.pointsto.meta.AnalysisUniverse) JavaKind(jdk.vm.ci.meta.JavaKind) Path(java.nio.file.Path) SubstrateStampProvider(com.oracle.svm.core.graal.meta.SubstrateStampProvider) StampProvider(org.graalvm.compiler.nodes.spi.StampProvider) CompileQueue(com.oracle.svm.hosted.code.CompileQueue) SubstrateSnippetReflectionProvider(com.oracle.svm.core.graal.meta.SubstrateSnippetReflectionProvider) AfterHeapLayoutAccessImpl(com.oracle.svm.hosted.FeatureImpl.AfterHeapLayoutAccessImpl) CFunctionSubstitutionProcessor(com.oracle.svm.hosted.code.CFunctionSubstitutionProcessor) AnnotationSubstitutionProcessor(com.oracle.svm.hosted.substitute.AnnotationSubstitutionProcessor) NativeImageHeap(com.oracle.svm.hosted.image.NativeImageHeap) NativeImageCodeCache(com.oracle.svm.hosted.image.NativeImageCodeCache) UserError(com.oracle.svm.core.util.UserError) VMError(com.oracle.svm.core.util.VMError) AnalysisMetaAccess(com.oracle.graal.pointsto.meta.AnalysisMetaAccess) AtomicReference(java.util.concurrent.atomic.AtomicReference) TypeState(com.oracle.graal.pointsto.typestate.TypeState) SubstrateGraphMakerFactory(com.oracle.svm.hosted.code.SubstrateGraphMakerFactory) CEntryPoint(org.graalvm.nativeimage.c.function.CEntryPoint) IOException(java.io.IOException) ExecutionException(java.util.concurrent.ExecutionException) UnsupportedFeatureException(com.oracle.graal.pointsto.constraints.UnsupportedFeatureException) CancellationException(java.util.concurrent.CancellationException) InvocationTargetException(java.lang.reflect.InvocationTargetException) HostedMetaAccess(com.oracle.svm.hosted.meta.HostedMetaAccess) SharedRuntimeConfigurationBuilder(com.oracle.svm.hosted.code.SharedRuntimeConfigurationBuilder) SVMBytecodeAnalysisPolicy(com.oracle.svm.hosted.analysis.SVMBytecodeAnalysisPolicy) DeclarativeSubstitutionProcessor(com.oracle.svm.hosted.substitute.DeclarativeSubstitutionProcessor) StopTimer(com.oracle.graal.pointsto.util.Timer.StopTimer) Timer(com.oracle.graal.pointsto.util.Timer) NativeMethodSubstitutionProcessor(com.oracle.svm.hosted.code.NativeMethodSubstitutionProcessor) AllocationSite(com.oracle.svm.core.allocationprofile.AllocationSite) SubstrateStampProvider(com.oracle.svm.core.graal.meta.SubstrateStampProvider) AnnotationSubstitutionProcessor(com.oracle.svm.hosted.substitute.AnnotationSubstitutionProcessor) DeclarativeSubstitutionProcessor(com.oracle.svm.hosted.substitute.DeclarativeSubstitutionProcessor) NativeMethodSubstitutionProcessor(com.oracle.svm.hosted.code.NativeMethodSubstitutionProcessor) SubstitutionProcessor(com.oracle.graal.pointsto.infrastructure.SubstitutionProcessor) UnsafeAutomaticSubstitutionProcessor(com.oracle.svm.hosted.substitute.UnsafeAutomaticSubstitutionProcessor) CFunctionSubstitutionProcessor(com.oracle.svm.hosted.code.CFunctionSubstitutionProcessor) OSInterface(com.oracle.svm.core.os.OSInterface) BeforeCompilationAccessImpl(com.oracle.svm.hosted.FeatureImpl.BeforeCompilationAccessImpl)

Example 10 with UnsupportedFeatureException

use of com.oracle.graal.pointsto.constraints.UnsupportedFeatureException in project graal by oracle.

the class ObjectScanner method scanArray.

/**
 * Scans constant arrays, one element at the time.
 *
 * @param array the array to be scanned
 * @param reason what triggered the scanning
 */
protected final void scanArray(JavaConstant array, Object reason) {
    Object valueObj = bb.getSnippetReflectionProvider().asObject(Object.class, array);
    AnalysisType arrayType = bb.getMetaAccess().lookupJavaType(valueObj.getClass());
    assert valueObj instanceof Object[];
    try {
        Object[] arrayObject = (Object[]) valueObj;
        for (int idx = 0; idx < arrayObject.length; idx++) {
            Object e = arrayObject[idx];
            if (e == null) {
                forNullArrayElement(array, arrayType, idx);
            } else {
                Object element = bb.getUniverse().replaceObject(e);
                JavaConstant elementConstant = bb.getSnippetReflectionProvider().forObject(element);
                AnalysisType elementType = bb.getMetaAccess().lookupJavaType(element.getClass());
                propagateRoot(array, elementConstant);
                /* Scan the array element. */
                scanConstant(elementConstant, reason);
                /* Process the array element. */
                forNonNullArrayElement(array, arrayType, elementConstant, elementType, idx);
            }
        }
    } catch (UnsupportedFeatureException ex) {
        unsupportedFeature(arrayType.toJavaName(true), ex.getMessage(), reason);
    }
}
Also used : AnalysisType(com.oracle.graal.pointsto.meta.AnalysisType) UnsupportedFeatureException(com.oracle.graal.pointsto.constraints.UnsupportedFeatureException) JavaConstant(jdk.vm.ci.meta.JavaConstant)

Aggregations

UnsupportedFeatureException (com.oracle.graal.pointsto.constraints.UnsupportedFeatureException)10 AnalysisType (com.oracle.graal.pointsto.meta.AnalysisType)4 JavaConstant (jdk.vm.ci.meta.JavaConstant)4 Delete (com.oracle.svm.core.annotate.Delete)3 JavaKind (jdk.vm.ci.meta.JavaKind)3 ResolvedJavaType (jdk.vm.ci.meta.ResolvedJavaType)3 AnalysisField (com.oracle.graal.pointsto.meta.AnalysisField)2 AnalysisMethod (com.oracle.graal.pointsto.meta.AnalysisMethod)2 SnippetReflectionProvider (org.graalvm.compiler.api.replacements.SnippetReflectionProvider)2 DebugContext (org.graalvm.compiler.debug.DebugContext)2 StructuredGraph (org.graalvm.compiler.nodes.StructuredGraph)2 WordTypes (org.graalvm.compiler.word.WordTypes)2 AnalysisPolicy (com.oracle.graal.pointsto.AnalysisPolicy)1 SubstitutionProcessor (com.oracle.graal.pointsto.infrastructure.SubstitutionProcessor)1 AnalysisMetaAccess (com.oracle.graal.pointsto.meta.AnalysisMetaAccess)1 AnalysisUniverse (com.oracle.graal.pointsto.meta.AnalysisUniverse)1 HostedProviders (com.oracle.graal.pointsto.meta.HostedProviders)1 TypeState (com.oracle.graal.pointsto.typestate.TypeState)1 Timer (com.oracle.graal.pointsto.util.Timer)1 StopTimer (com.oracle.graal.pointsto.util.Timer.StopTimer)1