Examples with HotSpotResolvedJavaType jdk.vm.ci.hotspot.HotSpotResolvedJavaType used on opensource projects

Example 1 with HotSpotResolvedJavaType

use of jdk.vm.ci.hotspot.HotSpotResolvedJavaType in project graal by oracle.

the class ReplaceConstantNodesPhase method handleHotSpotObjectConstant.

/**
 * Replace an object constant with an indirect load {@link ResolveConstantNode}. Currently we
 * support only strings.
 *
 * @param graph
 * @param stateMapper
 * @param node {@link ConstantNode} containing a {@link HotSpotObjectConstant} that needs
 *            resolution.
 */
private static void handleHotSpotObjectConstant(StructuredGraph graph, FrameStateMapperClosure stateMapper, ConstantNode node) {
    HotSpotObjectConstant constant = (HotSpotObjectConstant) node.asJavaConstant();
    HotSpotResolvedJavaType type = (HotSpotResolvedJavaType) constant.getType();
    if (type.mirror().equals(String.class)) {
        assert !constant.isCompressed() : "No support for replacing compressed oop constants";
        FixedWithNextNode replacement = graph.add(new ResolveConstantNode(node));
        insertReplacement(graph, stateMapper, node, replacement);
        node.replaceAtUsages(replacement, n -> !(n instanceof ResolveConstantNode));
    } else {
        throw new GraalError("Unsupported object constant type: " + type);
    }
}

Example 2 with HotSpotResolvedJavaType

use of jdk.vm.ci.hotspot.HotSpotResolvedJavaType in project graal by oracle.

the class HotSpotGraalMBean method optionsFor.

public OptionValues optionsFor(OptionValues initialValues, ResolvedJavaMethod forMethod) {
    ensureRegistered(true);
    if (forMethod instanceof HotSpotResolvedJavaMethod) {
        HotSpotResolvedObjectType type = ((HotSpotResolvedJavaMethod) forMethod).getDeclaringClass();
        if (type instanceof HotSpotResolvedJavaType) {
            Class<?> clazz = ((HotSpotResolvedJavaType) type).mirror();
            Reference<ClassLoader> addNewRef = new WeakReference<>(clazz.getClassLoader());
            if (!loaders.contains(addNewRef)) {
                EconomicSet<Reference<ClassLoader>> newLoaders = EconomicSet.create(RefEquivalence.INSTANCE, loaders);
                newLoaders.add(addNewRef);
                this.loaders = newLoaders;
            }
        }
    }
    return currentMap(initialValues, forMethod);
}

Example 3 with HotSpotResolvedJavaType

use of jdk.vm.ci.hotspot.HotSpotResolvedJavaType in project graal by oracle.

the class ReplaceConstantNodesPhase method replaceWithResolution.

/**
 * Replace the uses of a constant with either {@link LoadConstantIndirectlyNode} or
 * {@link ResolveConstantNode}.
 *
 * @param graph
 * @param stateMapper
 * @param node {@link ConstantNode} containing a {@link HotSpotResolvedJavaType} that needs
 *            resolution.
 */
private static void replaceWithResolution(StructuredGraph graph, FrameStateMapperClosure stateMapper, ConstantNode node) {
    HotSpotMetaspaceConstant metaspaceConstant = (HotSpotMetaspaceConstant) node.asConstant();
    HotSpotResolvedJavaType type = (HotSpotResolvedJavaType) metaspaceConstant.asResolvedJavaType();
    ResolvedJavaType topMethodHolder = graph.method().getDeclaringClass();
    ValueNode replacement;
    if (type.isArray() && type.getComponentType().isPrimitive()) {
        // Special case for primitive arrays. The AOT runtime pre-resolves them, so we may
        // omit the resolution call.
        replacement = graph.addOrUnique(new LoadConstantIndirectlyNode(node));
    } else if (type.equals(topMethodHolder) || (type.isAssignableFrom(topMethodHolder) && !type.isInterface())) {
        // If it's a supertype of or the same class that declares the top method, we are
        // guaranteed to have it resolved already. If it's an interface, we just test for
        // equality.
        replacement = graph.addOrUnique(new LoadConstantIndirectlyNode(node));
    } else {
        FixedWithNextNode fixedReplacement;
        if (builtIns.contains(type.mirror())) {
            // Special case of klass constants that come from {@link BoxingSnippets}.
            fixedReplacement = graph.add(new ResolveConstantNode(node, HotSpotConstantLoadAction.INITIALIZE));
        } else {
            fixedReplacement = graph.add(new ResolveConstantNode(node));
        }
        insertReplacement(graph, stateMapper, node, fixedReplacement);
        replacement = fixedReplacement;
    }
    node.replaceAtUsages(replacement, n -> !isReplacementNode(n));
}

Example 4 with HotSpotResolvedJavaType

use of jdk.vm.ci.hotspot.HotSpotResolvedJavaType in project graal by oracle.

the class ReplaceConstantNodesPhase method tryToReplaceWithExisting.

/**
 * Try to find dominating node doing the resolution that can be reused.
 *
 * @param graph
 * @param node {@link ConstantNode} containing a {@link HotSpotResolvedJavaType} that needs
 *            resolution.
 */
private static void tryToReplaceWithExisting(StructuredGraph graph, ConstantNode node) {
    ScheduleResult schedule = graph.getLastSchedule();
    NodeMap<Block> nodeToBlock = schedule.getNodeToBlockMap();
    BlockMap<List<Node>> blockToNodes = schedule.getBlockToNodesMap();
    EconomicMap<Block, Node> blockToExisting = EconomicMap.create();
    for (Node n : node.usages().filter(n -> isReplacementNode(n))) {
        blockToExisting.put(nodeToBlock.get(n), n);
    }
    for (Node use : node.usages().filter(n -> !isReplacementNode(n)).snapshot()) {
        boolean replaced = false;
        Block b = nodeToBlock.get(use);
        Node e = blockToExisting.get(b);
        if (e != null) {
            // the use is scheduled after it.
            for (Node n : blockToNodes.get(b)) {
                if (n.equals(use)) {
                    // Usage is before initialization, can't use it
                    break;
                }
                if (n.equals(e)) {
                    use.replaceFirstInput(node, e);
                    replaced = true;
                    break;
                }
            }
        }
        if (!replaced) {
            // Look for dominating blocks that have existing nodes
            for (Block d : blockToExisting.getKeys()) {
                if (strictlyDominates(d, b)) {
                    use.replaceFirstInput(node, blockToExisting.get(d));
                    break;
                }
            }
        }
    }
}

Example 5 with HotSpotResolvedJavaType

use of jdk.vm.ci.hotspot.HotSpotResolvedJavaType in project graal by oracle.

the class ReplaceConstantNodesPhase method handleHotSpotMetaspaceConstant.

/**
 * Replace {@link ConstantNode} containing a {@link HotSpotResolvedJavaType} with indirection.
 *
 * @param graph
 * @param stateMapper
 * @param node {@link ConstantNode} containing a {@link HotSpotResolvedJavaType} that needs
 *            resolution.
 */
private void handleHotSpotMetaspaceConstant(StructuredGraph graph, FrameStateMapperClosure stateMapper, ConstantNode node) {
    HotSpotMetaspaceConstant metaspaceConstant = (HotSpotMetaspaceConstant) node.asConstant();
    HotSpotResolvedJavaType type = (HotSpotResolvedJavaType) metaspaceConstant.asResolvedJavaType();
    if (type != null) {
        if (verifyFingerprints && checkForBadFingerprint(type)) {
            throw new GraalError("Type with bad fingerprint: " + type);
        }
        assert !metaspaceConstant.isCompressed() : "No support for replacing compressed metaspace constants";
        tryToReplaceWithExisting(graph, node);
        if (anyUsagesNeedReplacement(node)) {
            replaceWithResolution(graph, stateMapper, node);
        }
    } else {
        throw new GraalError("Unsupported metaspace constant type: " + type);
    }
}