Examples with ResolvedJavaType jdk.vm.ci.meta.ResolvedJavaType used on opensource projects

Example 61 with ResolvedJavaType

use of jdk.vm.ci.meta.ResolvedJavaType in project graal by oracle.

the class SubstrateGraphBuilderPlugins method registerKnownIntrinsicsPlugins.

private static void registerKnownIntrinsicsPlugins(InvocationPlugins plugins, boolean analysis) {
    Registration r = new Registration(plugins, KnownIntrinsics.class);
    r.register0("heapBase", new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) {
            b.addPush(JavaKind.Object, ReadRegisterFixedNode.forHeapBase());
            return true;
        }
    });
    r.register1("readArrayLength", Object.class, new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode array) {
            b.addPush(JavaKind.Int, new ArrayLengthNode(array));
            return true;
        }
    });
    r.register1("readHub", Object.class, new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode object) {
            ValueNode nonNullObject = b.nullCheckedValue(object);
            b.addPush(JavaKind.Object, new LoadHubNode(b.getStampProvider(), nonNullObject));
            return true;
        }
    });
    r.register3("formatObject", Pointer.class, Class.class, boolean.class, new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode memory, ValueNode hub, ValueNode rememberedSet) {
            b.addPush(JavaKind.Object, new FormatObjectNode(memory, hub, rememberedSet));
            return true;
        }
    });
    r.register5("formatArray", Pointer.class, Class.class, int.class, boolean.class, boolean.class, new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode memory, ValueNode hub, ValueNode length, ValueNode rememberedSet, ValueNode unaligned) {
            b.addPush(JavaKind.Object, new FormatArrayNode(memory, hub, length, rememberedSet, unaligned));
            return true;
        }
    });
    r.register2("unsafeCast", Object.class, Class.class, new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode object, ValueNode toTypeNode) {
            /*
                 * We need to make sure that the updated type information does not flow up, because
                 * it can depend on any condition before (and we do not know which condition, so we
                 * cannot anchor at a particular block).
                 */
            ResolvedJavaType toType = typeValue(b.getConstantReflection(), b, targetMethod, toTypeNode, "toType");
            TypeReference toTypeRef = TypeReference.createTrustedWithoutAssumptions(toType);
            b.addPush(JavaKind.Object, new FixedValueAnchorNode(object, StampFactory.object(toTypeRef)));
            return true;
        }
    });
    r.register1("nonNullPointer", Pointer.class, new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode object) {
            b.addPush(JavaKind.Object, new PiNode(object, nonZeroWord()));
            return true;
        }
    });
    r.register0("readStackPointer", new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) {
            b.addPush(JavaKind.Object, new ReadStackPointerNode());
            return true;
        }
    });
    r.register1("writeStackPointer", Pointer.class, new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode value) {
            b.add(new WriteStackPointerNode(value));
            return true;
        }
    });
    r.register0("readInstructionPointer", new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) {
            b.addPush(JavaKind.Object, new ReadInstructionPointerNode());
            return true;
        }
    });
    r.register0("readCallerStackPointer", new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) {
            b.addPush(JavaKind.Object, new ReadCallerStackPointerNode());
            return true;
        }
    });
    r.register0("readReturnAddress", new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) {
            b.addPush(JavaKind.Object, new ReadReturnAddressNode());
            return true;
        }
    });
    r.register3("farReturn", Object.class, Pointer.class, CodePointer.class, new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode result, ValueNode sp, ValueNode ip) {
            b.add(new FarReturnNode(result, sp, ip));
            return true;
        }
    });
    r.register0("testDeoptimize", new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) {
            b.add(new TestDeoptimizeNode());
            return true;
        }
    });
    r.register0("isDeoptimizationTarget", new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) {
            if (b.getGraph().method() instanceof SharedMethod) {
                SharedMethod method = (SharedMethod) b.getGraph().method();
                if (method.isDeoptTarget()) {
                    b.addPush(JavaKind.Boolean, ConstantNode.forBoolean(true));
                } else {
                    b.addPush(JavaKind.Boolean, ConstantNode.forBoolean(false));
                }
            } else {
                // In analysis the value is always true.
                b.addPush(JavaKind.Boolean, ConstantNode.forBoolean(true));
            }
            return true;
        }
    });
    r.register2("convertUnknownValue", Object.class, Class.class, new InvocationPlugin() {

        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode object, ValueNode typeNode) {
            ResolvedJavaType type = typeValue(b.getConstantReflection(), b, targetMethod, typeNode, "type");
            TypeReference typeRef = TypeReference.createTrustedWithoutAssumptions(type);
            Stamp stamp = StampFactory.object(typeRef);
            if (analysis) {
                b.addPush(JavaKind.Object, new ConvertUnknownValueNode(object, stamp));
            } else {
                b.addPush(JavaKind.Object, PiNode.create(object, stamp));
            }
            return true;
        }
    });
}

Example 62 with ResolvedJavaType

use of jdk.vm.ci.meta.ResolvedJavaType in project graal by oracle.

the class AnnotationSubstitutionProcessor method handleSubstitutionClass.

private void handleSubstitutionClass(Class<?> annotatedClass, Class<?> originalClass) {
    // Not sure what happens if the target class is in a hierarchy - so prohibit that for now.
    guarantee(annotatedClass.isInterface() == originalClass.isInterface(), "if original is interface, target must also be interface: %s", annotatedClass);
    guarantee(originalClass.getSuperclass() == Object.class || originalClass.isInterface(), "target class must inherit directly from Object: %s", originalClass);
    ResolvedJavaType original = metaAccess.lookupJavaType(originalClass);
    ResolvedJavaType annotated = metaAccess.lookupJavaType(annotatedClass);
    for (int i = 0; i < ARRAY_DIMENSIONS; i++) {
        ResolvedJavaType substitution = new SubstitutionType(original, annotated);
        register(typeSubstitutions, annotated, original, substitution);
        original = original.getArrayClass();
        annotated = annotated.getArrayClass();
    }
    for (Method m : annotatedClass.getDeclaredMethods()) {
        handleAnnotatedMethodInSubstitutionClass(m, originalClass);
    }
    for (Constructor<?> c : annotatedClass.getDeclaredConstructors()) {
        handleAnnotatedMethodInSubstitutionClass(c, originalClass);
    }
    for (Method m : originalClass.getDeclaredMethods()) {
        handleOriginalMethodInSubstitutionClass(m);
    }
    for (Constructor<?> c : originalClass.getDeclaredConstructors()) {
        handleOriginalMethodInSubstitutionClass(c);
    }
    for (Field f : originalClass.getDeclaredFields()) {
        registerAsDeleted(null, metaAccess.lookupJavaField(f), SUBSTITUTION_DELETE);
    }
    for (Field f : annotatedClass.getDeclaredFields()) {
        ResolvedJavaField field = metaAccess.lookupJavaField(f);
        ResolvedJavaField alias = fieldValueRecomputation(annotatedClass, field, field, f);
        if (!alias.equals(field)) {
            register(fieldSubstitutions, field, null, alias);
        }
    }
}

Example 63 with ResolvedJavaType

use of jdk.vm.ci.meta.ResolvedJavaType in project graal by oracle.

the class AnnotationSubstitutionProcessor method handleFieldInAliasClass.

private void handleFieldInAliasClass(Field annotatedField, Class<?> originalClass) {
    if (!NativeImageGenerator.includedIn(ImageSingletons.lookup(Platform.class), lookupAnnotation(annotatedField, Platforms.class))) {
        return;
    }
    ResolvedJavaField annotated = metaAccess.lookupJavaField(annotatedField);
    Delete deleteAnnotation = lookupAnnotation(annotatedField, Delete.class);
    Alias aliasAnnotation = lookupAnnotation(annotatedField, Alias.class);
    Inject injectAnnotation = lookupAnnotation(annotatedField, Inject.class);
    int numAnnotations = (deleteAnnotation != null ? 1 : 0) + (aliasAnnotation != null ? 1 : 0) + (injectAnnotation != null ? 1 : 0);
    if (numAnnotations == 0) {
        guarantee(annotatedField.getName().equals("$assertionsDisabled"), "One of @Delete, @Alias, or @Inject must be used: %s", annotatedField);
        /*
             * The field $assertionsDisabled can be present in the original class, but does not have
             * to. We treat it like an optional @Alias fields without field value recomputation.
             */
        ResolvedJavaField original = findOriginalField(annotatedField, originalClass, true);
        if (original != null) {
            register(fieldSubstitutions, annotated, null, original);
        }
        return;
    }
    guarantee(numAnnotations == 1, "Only one of @Delete, @Alias, or @Inject can be used: %s", annotatedField);
    if (injectAnnotation != null) {
        guarantee(!annotated.isStatic(), "@Inject field must not be static: %s", annotated);
        ResolvedJavaField injected = fieldValueRecomputation(originalClass, annotated, annotated, annotatedField);
        register(fieldSubstitutions, annotated, null, injected);
        ResolvedJavaType original = metaAccess.lookupJavaType(originalClass);
        InjectedFieldsType substitution;
        if (typeSubstitutions.get(original) instanceof InjectedFieldsType) {
            substitution = (InjectedFieldsType) typeSubstitutions.get(original);
            register(typeSubstitutions, annotated.getDeclaringClass(), original, substitution);
        } else {
            substitution = new InjectedFieldsType(original);
            register(typeSubstitutions, annotated.getDeclaringClass(), original, substitution);
        }
        substitution.addInjectedField(injected);
    } else {
        ResolvedJavaField original = findOriginalField(annotatedField, originalClass, false);
        if (original == null) {
            return;
        }
        guarantee(annotated.isStatic() == original.isStatic(), "Static modifier mismatch: %s, %s", annotated, original);
        guarantee(annotated.getJavaKind() == original.getJavaKind(), "Type mismatch: %s, %s", annotated, original);
        if (deleteAnnotation != null) {
            registerAsDeleted(annotated, original, deleteAnnotation);
        } else {
            ResolvedJavaField alias = fieldValueRecomputation(originalClass, original, annotated, annotatedField);
            register(fieldSubstitutions, annotated, original, alias);
        }
    }
}

Example 64 with ResolvedJavaType

use of jdk.vm.ci.meta.ResolvedJavaType in project graal by oracle.

the class NativeBootImage method writeMethodHeader.

private void writeMethodHeader(HostedMethod m, CSourceCodeWriter writer, boolean dynamic) {
    assert Modifier.isStatic(m.getModifiers()) : "Published methods that go into the header must be static.";
    CEntryPointData cEntryPointData = (CEntryPointData) m.getWrapped().getEntryPointData();
    String docComment = cEntryPointData.getDocumentation();
    if (docComment != null && !docComment.isEmpty()) {
        writer.appendln("/*");
        Arrays.stream(docComment.split("\n")).forEach(l -> writer.appendln(" * " + l));
        writer.appendln(" */");
    }
    if (dynamic) {
        writer.append("typedef ");
    }
    writer.append(CSourceCodeWriter.findCTypeName(metaAccess, nativeLibs, (ResolvedJavaType) m.getSignature().getReturnType(m.getDeclaringClass())));
    writer.append(" ");
    assert !cEntryPointData.getSymbolName().isEmpty();
    if (dynamic) {
        writer.append("(*").append(cEntryPointData.getSymbolName()).append("_fn_t)");
    } else {
        writer.append(cEntryPointData.getSymbolName());
    }
    writer.append("(");
    String sep = "";
    for (int i = 0; i < m.getSignature().getParameterCount(false); i++) {
        writer.append(sep);
        sep = ", ";
        writer.append(CSourceCodeWriter.findCTypeName(metaAccess, nativeLibs, (ResolvedJavaType) m.getSignature().getParameterType(i, m.getDeclaringClass())));
        Parameter param = m.getParameters()[i];
        if (param.isNamePresent()) {
            writer.append(" ");
            writer.append(param.getName());
        }
    }
    writer.appendln(");");
    writer.appendln();
}

Example 65 with ResolvedJavaType

use of jdk.vm.ci.meta.ResolvedJavaType in project graal by oracle.

the class CInterfaceEnumTool method invokeEnumValue.

private InvokeNode invokeEnumValue(GraphBuilderTool b, CallTargetFactory callTargetFactory, FrameStateBuilder frameState, int bci, EnumInfo enumInfo, ResolvedJavaMethod valueMethod, ValueNode arg) {
    ResolvedJavaType returnType = (ResolvedJavaType) valueMethod.getSignature().getReturnType(null);
    ValueNode[] args = new ValueNode[2];
    args[0] = ConstantNode.forConstant(snippetReflection.forObject(enumInfo.getRuntimeData()), b.getMetaAccess(), b.getGraph());
    args[1] = arg;
    StampPair returnStamp = StampFactory.forDeclaredType(null, returnType, false);
    MethodCallTargetNode callTargetNode = b.append(callTargetFactory.createMethodCallTarget(InvokeKind.Virtual, valueMethod, args, returnStamp, bci));
    Stamp invokeStamp = StampFactory.forKind(returnType.getJavaKind());
    InvokeNode invoke = b.append(new InvokeNode(callTargetNode, bci, invokeStamp));
    frameState.push(returnType.getJavaKind(), invoke);
    FrameState stateWithInvoke = frameState.create(bci, invoke);
    frameState.pop(returnType.getJavaKind());
    invoke.setStateAfter(stateWithInvoke);
    return invoke;
}