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

Example 41 with JavaType

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

the class StampFactory method createParameterStamps.

public static Stamp[] createParameterStamps(Assumptions assumptions, ResolvedJavaMethod method, boolean trustInterfaceTypes) {
    Signature signature = method.getSignature();
    Stamp[] result = new Stamp[signature.getParameterCount(method.hasReceiver())];
    int index = 0;
    ResolvedJavaType accessingClass = method.getDeclaringClass();
    if (method.hasReceiver()) {
        if (trustInterfaceTypes) {
            result[index++] = StampFactory.objectNonNull(TypeReference.createTrusted(assumptions, accessingClass));
        } else {
            result[index++] = StampFactory.objectNonNull(TypeReference.create(assumptions, accessingClass));
        }
    }
    for (int i = 0; i < signature.getParameterCount(false); i++) {
        JavaType type = signature.getParameterType(i, accessingClass);
        JavaKind kind = type.getJavaKind();
        Stamp stamp;
        if (kind == JavaKind.Object && type instanceof ResolvedJavaType) {
            if (trustInterfaceTypes) {
                stamp = StampFactory.object(TypeReference.createTrusted(assumptions, (ResolvedJavaType) type));
            } else {
                stamp = StampFactory.object(TypeReference.create(assumptions, (ResolvedJavaType) type));
            }
        } else {
            stamp = StampFactory.forKind(kind);
        }
        result[index++] = stamp;
    }
    return result;
}

Example 42 with JavaType

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

the class DefaultHotSpotLoweringProvider method lowerInvoke.

private void lowerInvoke(Invoke invoke, LoweringTool tool, StructuredGraph graph) {
    if (invoke.callTarget() instanceof MethodCallTargetNode) {
        MethodCallTargetNode callTarget = (MethodCallTargetNode) invoke.callTarget();
        NodeInputList<ValueNode> parameters = callTarget.arguments();
        ValueNode receiver = parameters.size() <= 0 ? null : parameters.get(0);
        if (!callTarget.isStatic() && receiver.stamp(NodeView.DEFAULT) instanceof ObjectStamp && !StampTool.isPointerNonNull(receiver)) {
            ValueNode nonNullReceiver = createNullCheckedValue(receiver, invoke.asNode(), tool);
            parameters.set(0, nonNullReceiver);
            receiver = nonNullReceiver;
        }
        JavaType[] signature = callTarget.targetMethod().getSignature().toParameterTypes(callTarget.isStatic() ? null : callTarget.targetMethod().getDeclaringClass());
        LoweredCallTargetNode loweredCallTarget = null;
        OptionValues options = graph.getOptions();
        if (InlineVTableStubs.getValue(options) && callTarget.invokeKind().isIndirect() && (AlwaysInlineVTableStubs.getValue(options) || invoke.isPolymorphic())) {
            HotSpotResolvedJavaMethod hsMethod = (HotSpotResolvedJavaMethod) callTarget.targetMethod();
            ResolvedJavaType receiverType = invoke.getReceiverType();
            if (hsMethod.isInVirtualMethodTable(receiverType)) {
                JavaKind wordKind = runtime.getTarget().wordJavaKind;
                ValueNode hub = createReadHub(graph, receiver, tool);
                ReadNode metaspaceMethod = createReadVirtualMethod(graph, hub, hsMethod, receiverType);
                // We use LocationNode.ANY_LOCATION for the reads that access the
                // compiled code entry as HotSpot does not guarantee they are final
                // values.
                int methodCompiledEntryOffset = runtime.getVMConfig().methodCompiledEntryOffset;
                AddressNode address = createOffsetAddress(graph, metaspaceMethod, methodCompiledEntryOffset);
                ReadNode compiledEntry = graph.add(new ReadNode(address, any(), StampFactory.forKind(wordKind), BarrierType.NONE));
                loweredCallTarget = graph.add(new HotSpotIndirectCallTargetNode(metaspaceMethod, compiledEntry, parameters.toArray(new ValueNode[parameters.size()]), callTarget.returnStamp(), signature, callTarget.targetMethod(), HotSpotCallingConventionType.JavaCall, callTarget.invokeKind()));
                graph.addBeforeFixed(invoke.asNode(), metaspaceMethod);
                graph.addAfterFixed(metaspaceMethod, compiledEntry);
            }
        }
        if (loweredCallTarget == null) {
            loweredCallTarget = graph.add(new HotSpotDirectCallTargetNode(parameters.toArray(new ValueNode[parameters.size()]), callTarget.returnStamp(), signature, callTarget.targetMethod(), HotSpotCallingConventionType.JavaCall, callTarget.invokeKind()));
        }
        callTarget.replaceAndDelete(loweredCallTarget);
    }
}

Example 43 with JavaType

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

the class HotSpotForeignCallLinkageImpl method createCallingConvention.

/**
 * Gets a calling convention for a given descriptor and call type.
 */
public static CallingConvention createCallingConvention(MetaAccessProvider metaAccess, CodeCacheProvider codeCache, WordTypes wordTypes, ValueKindFactory<?> valueKindFactory, ForeignCallDescriptor descriptor, Type ccType) {
    assert ccType != null;
    Class<?>[] argumentTypes = descriptor.getArgumentTypes();
    JavaType[] parameterTypes = new JavaType[argumentTypes.length];
    for (int i = 0; i < parameterTypes.length; ++i) {
        parameterTypes[i] = asJavaType(argumentTypes[i], metaAccess, wordTypes);
    }
    JavaType returnType = asJavaType(descriptor.getResultType(), metaAccess, wordTypes);
    RegisterConfig regConfig = codeCache.getRegisterConfig();
    return regConfig.getCallingConvention(ccType, returnType, parameterTypes, valueKindFactory);
}

Example 44 with JavaType

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

the class HotSpotHostBackend method makeCallingConvention.

protected CallingConvention makeCallingConvention(StructuredGraph graph, Stub stub) {
    if (stub != null) {
        return stub.getLinkage().getIncomingCallingConvention();
    }
    CallingConvention cc = getCallingConvention(getCodeCache(), HotSpotCallingConventionType.JavaCallee, graph.method(), this);
    if (graph.getEntryBCI() != JVMCICompiler.INVOCATION_ENTRY_BCI) {
        // for OSR, only a pointer is passed to the method.
        JavaType[] parameterTypes = new JavaType[] { getMetaAccess().lookupJavaType(long.class) };
        CallingConvention tmp = getCodeCache().getRegisterConfig().getCallingConvention(HotSpotCallingConventionType.JavaCallee, getMetaAccess().lookupJavaType(void.class), parameterTypes, this);
        cc = new CallingConvention(cc.getStackSize(), cc.getReturn(), tmp.getArgument(0));
    }
    return cc;
}

Example 45 with JavaType

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

the class WordOperationPlugin method processWordOperation.

protected void processWordOperation(GraphBuilderContext b, ValueNode[] args, ResolvedJavaMethod wordMethod) throws GraalError {
    JavaKind returnKind = wordMethod.getSignature().getReturnKind();
    WordFactory.FactoryOperation factoryOperation = BridgeMethodUtils.getAnnotation(WordFactory.FactoryOperation.class, wordMethod);
    if (factoryOperation != null) {
        switch(factoryOperation.opcode()) {
            case ZERO:
                assert args.length == 0;
                b.addPush(returnKind, forIntegerKind(wordKind, 0L));
                return;
            case FROM_UNSIGNED:
                assert args.length == 1;
                b.push(returnKind, fromUnsigned(b, args[0]));
                return;
            case FROM_SIGNED:
                assert args.length == 1;
                b.push(returnKind, fromSigned(b, args[0]));
                return;
        }
    }
    Word.Operation operation = BridgeMethodUtils.getAnnotation(Word.Operation.class, wordMethod);
    if (operation == null) {
        throw bailout(b, "Cannot call method on a word value: " + wordMethod.format("%H.%n(%p)"));
    }
    switch(operation.opcode()) {
        case NODE_CLASS:
            assert args.length == 2;
            ValueNode left = args[0];
            ValueNode right = operation.rightOperandIsInt() ? toUnsigned(b, args[1], JavaKind.Int) : fromSigned(b, args[1]);
            b.addPush(returnKind, createBinaryNodeInstance(operation.node(), left, right));
            break;
        case COMPARISON:
            assert args.length == 2;
            b.push(returnKind, comparisonOp(b, operation.condition(), args[0], fromSigned(b, args[1])));
            break;
        case IS_NULL:
            assert args.length == 1;
            b.push(returnKind, comparisonOp(b, Condition.EQ, args[0], ConstantNode.forIntegerKind(wordKind, 0L)));
            break;
        case IS_NON_NULL:
            assert args.length == 1;
            b.push(returnKind, comparisonOp(b, Condition.NE, args[0], ConstantNode.forIntegerKind(wordKind, 0L)));
            break;
        case NOT:
            assert args.length == 1;
            b.addPush(returnKind, new XorNode(args[0], b.add(forIntegerKind(wordKind, -1))));
            break;
        case READ_POINTER:
        case READ_OBJECT:
        case READ_BARRIERED:
            {
                assert args.length == 2 || args.length == 3;
                JavaKind readKind = wordTypes.asKind(wordMethod.getSignature().getReturnType(wordMethod.getDeclaringClass()));
                AddressNode address = makeAddress(b, args[0], args[1]);
                LocationIdentity location;
                if (args.length == 2) {
                    location = any();
                } else {
                    assert args[2].isConstant();
                    location = snippetReflection.asObject(LocationIdentity.class, args[2].asJavaConstant());
                }
                b.push(returnKind, readOp(b, readKind, address, location, operation.opcode()));
                break;
            }
        case READ_HEAP:
            {
                assert args.length == 3;
                JavaKind readKind = wordTypes.asKind(wordMethod.getSignature().getReturnType(wordMethod.getDeclaringClass()));
                AddressNode address = makeAddress(b, args[0], args[1]);
                BarrierType barrierType = snippetReflection.asObject(BarrierType.class, args[2].asJavaConstant());
                b.push(returnKind, readOp(b, readKind, address, any(), barrierType, true));
                break;
            }
        case WRITE_POINTER:
        case WRITE_OBJECT:
        case WRITE_BARRIERED:
        case INITIALIZE:
            {
                assert args.length == 3 || args.length == 4;
                JavaKind writeKind = wordTypes.asKind(wordMethod.getSignature().getParameterType(wordMethod.isStatic() ? 2 : 1, wordMethod.getDeclaringClass()));
                AddressNode address = makeAddress(b, args[0], args[1]);
                LocationIdentity location;
                if (args.length == 3) {
                    location = any();
                } else {
                    assert args[3].isConstant();
                    location = snippetReflection.asObject(LocationIdentity.class, args[3].asJavaConstant());
                }
                writeOp(b, writeKind, address, location, args[2], operation.opcode());
                break;
            }
        case TO_RAW_VALUE:
            assert args.length == 1;
            b.push(returnKind, toUnsigned(b, args[0], JavaKind.Long));
            break;
        case OBJECT_TO_TRACKED:
            assert args.length == 1;
            WordCastNode objectToTracked = b.add(WordCastNode.objectToTrackedPointer(args[0], wordKind));
            b.push(returnKind, objectToTracked);
            break;
        case OBJECT_TO_UNTRACKED:
            assert args.length == 1;
            WordCastNode objectToUntracked = b.add(WordCastNode.objectToUntrackedPointer(args[0], wordKind));
            b.push(returnKind, objectToUntracked);
            break;
        case FROM_ADDRESS:
            assert args.length == 1;
            WordCastNode addressToWord = b.add(WordCastNode.addressToWord(args[0], wordKind));
            b.push(returnKind, addressToWord);
            break;
        case TO_OBJECT:
            assert args.length == 1;
            WordCastNode wordToObject = b.add(WordCastNode.wordToObject(args[0], wordKind));
            b.push(returnKind, wordToObject);
            break;
        case TO_OBJECT_NON_NULL:
            assert args.length == 1;
            WordCastNode wordToObjectNonNull = b.add(WordCastNode.wordToObjectNonNull(args[0], wordKind));
            b.push(returnKind, wordToObjectNonNull);
            break;
        case CAS_POINTER:
            assert args.length == 5;
            AddressNode address = makeAddress(b, args[0], args[1]);
            JavaKind valueKind = wordTypes.asKind(wordMethod.getSignature().getParameterType(1, wordMethod.getDeclaringClass()));
            assert valueKind.equals(wordTypes.asKind(wordMethod.getSignature().getParameterType(2, wordMethod.getDeclaringClass()))) : wordMethod.getSignature();
            assert args[4].isConstant() : Arrays.toString(args);
            LocationIdentity location = snippetReflection.asObject(LocationIdentity.class, args[4].asJavaConstant());
            JavaType returnType = wordMethod.getSignature().getReturnType(wordMethod.getDeclaringClass());
            b.addPush(returnKind, casOp(valueKind, wordTypes.asKind(returnType), address, location, args[2], args[3]));
            break;
        default:
            throw new GraalError("Unknown opcode: %s", operation.opcode());
    }
}