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

Example 56 with ResolvedJavaType

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

the class GraalCompilerTest method checkArgs.

protected void checkArgs(ResolvedJavaMethod method, Object[] args) {
    JavaType[] sig = method.toParameterTypes();
    Assert.assertEquals(sig.length, args.length);
    for (int i = 0; i < args.length; i++) {
        JavaType javaType = sig[i];
        JavaKind kind = javaType.getJavaKind();
        Object arg = args[i];
        if (kind == JavaKind.Object) {
            if (arg != null && javaType instanceof ResolvedJavaType) {
                ResolvedJavaType resolvedJavaType = (ResolvedJavaType) javaType;
                Assert.assertTrue(resolvedJavaType + " from " + getMetaAccess().lookupJavaType(arg.getClass()), resolvedJavaType.isAssignableFrom(getMetaAccess().lookupJavaType(arg.getClass())));
            }
        } else {
            Assert.assertNotNull(arg);
            Assert.assertEquals(kind.toBoxedJavaClass(), arg.getClass());
        }
    }
}

Example 57 with ResolvedJavaType

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

the class StampFactory method forDeclaredType.

public static StampPair forDeclaredType(Assumptions assumptions, JavaType returnType, boolean nonNull) {
    if (returnType.getJavaKind() == JavaKind.Object && returnType instanceof ResolvedJavaType) {
        ResolvedJavaType resolvedJavaType = (ResolvedJavaType) returnType;
        TypeReference reference = TypeReference.create(assumptions, resolvedJavaType);
        ResolvedJavaType elementalType = resolvedJavaType.getElementalType();
        if (elementalType.isInterface()) {
            assert reference == null || !reference.getType().equals(resolvedJavaType);
            TypeReference uncheckedType;
            ResolvedJavaType elementalImplementor = elementalType.getSingleImplementor();
            if (elementalImplementor != null && !elementalType.equals(elementalImplementor)) {
                ResolvedJavaType implementor = elementalImplementor;
                ResolvedJavaType t = resolvedJavaType;
                while (t.isArray()) {
                    implementor = implementor.getArrayClass();
                    t = t.getComponentType();
                }
                uncheckedType = TypeReference.createTrusted(assumptions, implementor);
            } else {
                uncheckedType = TypeReference.createTrusted(assumptions, resolvedJavaType);
            }
            return StampPair.create(StampFactory.object(reference, nonNull), StampFactory.object(uncheckedType, nonNull));
        }
        return StampPair.createSingle(StampFactory.object(reference, nonNull));
    } else {
        return StampPair.createSingle(StampFactory.forKind(returnType.getJavaKind()));
    }
}

Example 58 with ResolvedJavaType

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

the class DynamicPiNode method findSynonym.

private static ValueNode findSynonym(Assumptions assumptions, ConstantReflectionProvider constantReflection, ValueNode object, GuardingNode guard, ValueNode typeMirror, boolean exact) {
    if (typeMirror.isConstant()) {
        ResolvedJavaType t = constantReflection.asJavaType(typeMirror.asConstant());
        if (t != null) {
            Stamp staticPiStamp;
            if (t.isPrimitive()) {
                staticPiStamp = StampFactory.alwaysNull();
            } else {
                TypeReference type = exact ? TypeReference.createExactTrusted(t) : TypeReference.createTrusted(assumptions, t);
                staticPiStamp = StampFactory.object(type);
            }
            return PiNode.create(object, staticPiStamp, (ValueNode) guard);
        }
    }
    return null;
}

Example 59 with ResolvedJavaType

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

the class PEReadEliminationClosure method processUnsafeLoad.

private boolean processUnsafeLoad(RawLoadNode load, PEReadEliminationBlockState state, GraphEffectList effects) {
    if (load.offset().isConstant()) {
        ResolvedJavaType type = StampTool.typeOrNull(load.object());
        if (type != null && type.isArray()) {
            JavaKind accessKind = load.accessKind();
            JavaKind componentKind = type.getComponentType().getJavaKind();
            long offset = load.offset().asJavaConstant().asLong();
            int index = VirtualArrayNode.entryIndexForOffset(tool.getArrayOffsetProvider(), offset, accessKind, type.getComponentType(), Integer.MAX_VALUE);
            ValueNode object = GraphUtil.unproxify(load.object());
            LocationIdentity location = NamedLocationIdentity.getArrayLocation(componentKind);
            ValueNode cachedValue = state.getReadCache(object, location, index, accessKind, this);
            assert cachedValue == null || load.stamp(NodeView.DEFAULT).isCompatible(cachedValue.stamp(NodeView.DEFAULT)) : "The RawLoadNode's stamp is not compatible with the cached value.";
            if (cachedValue != null) {
                effects.replaceAtUsages(load, cachedValue, load);
                addScalarAlias(load, cachedValue);
                return true;
            } else {
                state.addReadCache(object, location, index, accessKind, isOverflowAccess(accessKind, componentKind), load, this);
            }
        }
    }
    return false;
}

Example 60 with ResolvedJavaType

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

the class ReadEliminationClosure method processNode.

@Override
protected boolean processNode(Node node, ReadEliminationBlockState state, GraphEffectList effects, FixedWithNextNode lastFixedNode) {
    boolean deleted = false;
    if (node instanceof AccessFieldNode) {
        AccessFieldNode access = (AccessFieldNode) node;
        if (access.isVolatile()) {
            processIdentity(state, any());
        } else {
            ValueNode object = GraphUtil.unproxify(access.object());
            LoadCacheEntry identifier = new LoadCacheEntry(object, new FieldLocationIdentity(access.field()));
            ValueNode cachedValue = state.getCacheEntry(identifier);
            if (node instanceof LoadFieldNode) {
                if (cachedValue != null && access.stamp(NodeView.DEFAULT).isCompatible(cachedValue.stamp(NodeView.DEFAULT))) {
                    effects.replaceAtUsages(access, cachedValue, access);
                    addScalarAlias(access, cachedValue);
                    deleted = true;
                } else {
                    state.addCacheEntry(identifier, access);
                }
            } else {
                assert node instanceof StoreFieldNode;
                StoreFieldNode store = (StoreFieldNode) node;
                ValueNode value = getScalarAlias(store.value());
                if (GraphUtil.unproxify(value) == GraphUtil.unproxify(cachedValue)) {
                    effects.deleteNode(store);
                    deleted = true;
                }
                state.killReadCache(identifier.identity);
                state.addCacheEntry(identifier, value);
            }
        }
    } else if (node instanceof ReadNode) {
        ReadNode read = (ReadNode) node;
        if (read.getLocationIdentity().isSingle()) {
            ValueNode object = GraphUtil.unproxify(read.getAddress());
            LoadCacheEntry identifier = new LoadCacheEntry(object, read.getLocationIdentity());
            ValueNode cachedValue = state.getCacheEntry(identifier);
            if (cachedValue != null && areValuesReplaceable(read, cachedValue, considerGuards)) {
                effects.replaceAtUsages(read, cachedValue, read);
                addScalarAlias(read, cachedValue);
                deleted = true;
            } else {
                state.addCacheEntry(identifier, read);
            }
        }
    } else if (node instanceof WriteNode) {
        WriteNode write = (WriteNode) node;
        if (write.getLocationIdentity().isSingle()) {
            ValueNode object = GraphUtil.unproxify(write.getAddress());
            LoadCacheEntry identifier = new LoadCacheEntry(object, write.getLocationIdentity());
            ValueNode cachedValue = state.getCacheEntry(identifier);
            ValueNode value = getScalarAlias(write.value());
            if (GraphUtil.unproxify(value) == GraphUtil.unproxify(cachedValue)) {
                effects.deleteNode(write);
                deleted = true;
            }
            processIdentity(state, write.getLocationIdentity());
            state.addCacheEntry(identifier, value);
        } else {
            processIdentity(state, write.getLocationIdentity());
        }
    } else if (node instanceof UnsafeAccessNode) {
        ResolvedJavaType type = StampTool.typeOrNull(((UnsafeAccessNode) node).object());
        if (type != null && !type.isArray()) {
            if (node instanceof RawLoadNode) {
                RawLoadNode load = (RawLoadNode) node;
                if (load.getLocationIdentity().isSingle()) {
                    ValueNode object = GraphUtil.unproxify(load.object());
                    UnsafeLoadCacheEntry identifier = new UnsafeLoadCacheEntry(object, load.offset(), load.getLocationIdentity());
                    ValueNode cachedValue = state.getCacheEntry(identifier);
                    if (cachedValue != null && areValuesReplaceable(load, cachedValue, considerGuards)) {
                        effects.replaceAtUsages(load, cachedValue, load);
                        addScalarAlias(load, cachedValue);
                        deleted = true;
                    } else {
                        state.addCacheEntry(identifier, load);
                    }
                }
            } else {
                assert node instanceof RawStoreNode;
                RawStoreNode write = (RawStoreNode) node;
                if (write.getLocationIdentity().isSingle()) {
                    ValueNode object = GraphUtil.unproxify(write.object());
                    UnsafeLoadCacheEntry identifier = new UnsafeLoadCacheEntry(object, write.offset(), write.getLocationIdentity());
                    ValueNode cachedValue = state.getCacheEntry(identifier);
                    ValueNode value = getScalarAlias(write.value());
                    if (GraphUtil.unproxify(value) == GraphUtil.unproxify(cachedValue)) {
                        effects.deleteNode(write);
                        deleted = true;
                    }
                    processIdentity(state, write.getLocationIdentity());
                    state.addCacheEntry(identifier, value);
                } else {
                    processIdentity(state, write.getLocationIdentity());
                }
            }
        }
    } else if (node instanceof MemoryCheckpoint.Single) {
        LocationIdentity identity = ((MemoryCheckpoint.Single) node).getLocationIdentity();
        processIdentity(state, identity);
    } else if (node instanceof MemoryCheckpoint.Multi) {
        for (LocationIdentity identity : ((MemoryCheckpoint.Multi) node).getLocationIdentities()) {
            processIdentity(state, identity);
        }
    }
    return deleted;
}