diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/java/BytecodeParser.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/java/BytecodeParser.java index 770d22fc45fb..028745acca5d 100644 --- a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/java/BytecodeParser.java +++ b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/java/BytecodeParser.java @@ -1022,7 +1022,7 @@ public FixedWithNextNode getBeforeUnwindNode() { @SuppressWarnings("try") protected void buildRootMethod() { FrameStateBuilder startFrameState = new FrameStateBuilder(this, code, graph, graphBuilderConfig.retainLocalVariables()); - startFrameState.initializeForMethodStart(graph.getAssumptions(), graphBuilderConfig.eagerResolving() || intrinsicContext != null, graphBuilderConfig.getPlugins()); + startFrameState.initializeForMethodStart(graph.getAssumptions(), graphBuilderConfig.eagerResolving() || intrinsicContext != null, graphBuilderConfig.getPlugins(), null); try (IntrinsicScope s = intrinsicContext != null ? new IntrinsicScope(this) : null) { build(graph.start(), startFrameState); diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/java/FrameStateBuilder.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/java/FrameStateBuilder.java index 2938fd9bde84..3e4ed0d8ca71 100644 --- a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/java/FrameStateBuilder.java +++ b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/java/FrameStateBuilder.java @@ -207,7 +207,7 @@ public void initializeFromArgumentsArray(ValueNode[] arguments) { } } - public void initializeForMethodStart(Assumptions assumptions, boolean eagerResolve, Plugins plugins) { + public void initializeForMethodStart(Assumptions assumptions, boolean eagerResolve, Plugins plugins, List collectParameterNodes) { int javaIndex = 0; int index = 0; @@ -236,7 +236,11 @@ public void initializeForMethodStart(Assumptions assumptions, boolean eagerResol receiver = new ParameterNode(javaIndex, receiverStamp); } - locals[javaIndex] = graph.addOrUniqueWithInputs(receiver); + receiver = graph.addOrUniqueWithInputs(receiver); + locals[javaIndex] = receiver; + if (collectParameterNodes != null) { + collectParameterNodes.add(receiver); + } javaIndex = 1; index = 1; } @@ -275,7 +279,11 @@ public void initializeForMethodStart(Assumptions assumptions, boolean eagerResol param = new ParameterNode(index, stamp); } - locals[javaIndex] = graph.addOrUniqueWithInputs(param); + param = graph.addOrUniqueWithInputs(param); + locals[javaIndex] = param; + if (collectParameterNodes != null) { + collectParameterNodes.add(param); + } javaIndex++; if (kind.needsTwoSlots()) { locals[javaIndex] = TWO_SLOT_MARKER; diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/replacements/IntrinsicGraphBuilder.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/replacements/IntrinsicGraphBuilder.java index 624e328ca286..48a2c18e41bb 100644 --- a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/replacements/IntrinsicGraphBuilder.java +++ b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/replacements/IntrinsicGraphBuilder.java @@ -93,7 +93,7 @@ public class IntrinsicGraphBuilder extends CoreProvidersDelegate implements Grap private FrameState createStateAfterStartOfReplacementGraph(ResolvedJavaMethod original, GraphBuilderConfiguration graphBuilderConfig) { FrameStateBuilder startFrameState = new FrameStateBuilder(this, code, graph, graphBuilderConfig.retainLocalVariables()); - startFrameState.initializeForMethodStart(graph.getAssumptions(), false, graphBuilderConfig.getPlugins()); + startFrameState.initializeForMethodStart(graph.getAssumptions(), false, graphBuilderConfig.getPlugins(), null); return startFrameState.createInitialIntrinsicFrameState(original); } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/PointsToAnalysis.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/PointsToAnalysis.java index 4889e621ce3c..5def0656c55f 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/PointsToAnalysis.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/PointsToAnalysis.java @@ -87,7 +87,6 @@ import jdk.vm.ci.meta.JavaKind; import jdk.vm.ci.meta.JavaType; import jdk.vm.ci.meta.ResolvedJavaField; -import jdk.vm.ci.meta.Signature; public abstract class PointsToAnalysis extends AbstractAnalysisEngine { /** The type of {@link java.lang.Object}. */ @@ -321,10 +320,8 @@ public AnalysisMethod addRootMethod(Executable method, boolean invokeSpecial, Ob public AnalysisMethod addRootMethod(AnalysisMethod aMethod, boolean invokeSpecial, Object reason, MultiMethod.MultiMethodKey... otherRoots) { assert !universe.sealed() : "Cannot register root methods after analysis universe is sealed."; AnalysisError.guarantee(aMethod.isOriginalMethod()); - AnalysisType declaringClass = aMethod.getDeclaringClass(); boolean isStatic = aMethod.isStatic(); - Signature signature = aMethod.getSignature(); - int paramCount = signature.getParameterCount(!isStatic); + int paramCount = aMethod.getSignature().getParameterCount(!isStatic); PointsToAnalysisMethod originalPTAMethod = assertPointsToAnalysisMethod(aMethod); if (isStatic) { @@ -339,7 +336,7 @@ public AnalysisMethod addRootMethod(AnalysisMethod aMethod, boolean invokeSpecia pointsToMethod.registerAsImplementationInvoked(reason.toString()); MethodFlowsGraphInfo flowInfo = analysisPolicy.staticRootMethodGraph(this, pointsToMethod); for (int idx = 0; idx < paramCount; idx++) { - AnalysisType declaredParamType = (AnalysisType) signature.getParameterType(idx, declaringClass); + AnalysisType declaredParamType = aMethod.getSignature().getParameterType(idx); FormalParamTypeFlow parameter = flowInfo.getParameter(idx); processParam(declaredParamType, parameter); } @@ -399,7 +396,7 @@ public AnalysisMethod addRootMethod(AnalysisMethod aMethod, boolean invokeSpecia * type below we use idx-1 but when accessing the actual parameter flow we * simply use idx. */ - AnalysisType declaredParamType = (AnalysisType) signature.getParameterType(idx - 1, declaringClass); + AnalysisType declaredParamType = aMethod.getSignature().getParameterType(idx - 1); TypeFlow actualParameterFlow = invoke.getActualParameter(idx); processParam(declaredParamType, actualParameterFlow); } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/MethodTypeFlowBuilder.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/MethodTypeFlowBuilder.java index 931d698dcf9c..c5c67b3d951f 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/MethodTypeFlowBuilder.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/MethodTypeFlowBuilder.java @@ -148,7 +148,6 @@ import jdk.vm.ci.meta.Constant; import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.JavaKind; -import jdk.vm.ci.meta.JavaType; import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.VMConstant; @@ -411,7 +410,7 @@ private static void registerForeignCall(PointsToAnalysis bb, ForeignCallsProvide private boolean handleNodeIntrinsic() { if (AnnotationAccess.isAnnotationPresent(method, NodeIntrinsic.class)) { graph.getDebug().log("apply MethodTypeFlow on node intrinsic %s", method); - AnalysisType returnType = (AnalysisType) method.getSignature().getReturnType(method.getDeclaringClass()); + AnalysisType returnType = method.getSignature().getReturnType(); if (bb.isSupportedJavaKind(returnType.getJavaKind())) { /* * This is a method used in a snippet, so most likely the return value does not @@ -436,7 +435,7 @@ private boolean handleNodeIntrinsic() { private void insertAllInstantiatedTypesReturn() { AnalysisError.guarantee(flowsGraph.getReturnFlow() == null, "Expected null return flow"); - AnalysisType returnType = TypeFlow.filterUncheckedInterface((AnalysisType) method.getSignature().getReturnType(method.getDeclaringClass())); + AnalysisType returnType = TypeFlow.filterUncheckedInterface(method.getSignature().getReturnType()); AnalysisError.guarantee(returnType.getJavaKind().isObject(), "Unexpected return type: %s", returnType); BytecodePosition position = AbstractAnalysisEngine.syntheticSourcePosition(null, method); @@ -451,15 +450,14 @@ private void insertAllInstantiatedTypesReturn() { * Placeholder flows are placed in the graph for any missing flows. */ private void insertPlaceholderParamAndReturnFlows() { - boolean isStatic = Modifier.isStatic(method.getModifiers()); - JavaType[] paramTypes = method.getSignature().toParameterTypes(isStatic ? null : method.getDeclaringClass()); + var paramTypes = method.toParameterList(); BytecodePosition position = AbstractAnalysisEngine.syntheticSourcePosition(null, method); - for (int index = 0; index < paramTypes.length; index++) { + for (int index = 0; index < paramTypes.size(); index++) { if (flowsGraph.getParameter(index) == null) { - if (bb.isSupportedJavaKind(paramTypes[index].getJavaKind())) { - AnalysisType paramType = (AnalysisType) paramTypes[index]; + if (bb.isSupportedJavaKind(paramTypes.get(index).getJavaKind())) { + AnalysisType paramType = paramTypes.get(index); FormalParamTypeFlow parameter; - if (!isStatic && index == 0) { + if (index == 0 && !method.isStatic()) { assert paramType.equals(method.getDeclaringClass()) : paramType + ", " + method; parameter = new FormalReceiverTypeFlow(position, paramType); } else { @@ -471,7 +469,7 @@ private void insertPlaceholderParamAndReturnFlows() { } if (flowsGraph.getReturnFlow() == null) { - AnalysisType returnType = (AnalysisType) method.getSignature().getReturnType(method.getDeclaringClass()); + AnalysisType returnType = method.getSignature().getReturnType(); if (bb.isSupportedJavaKind(returnType.getJavaKind())) { flowsGraph.setReturnFlow(new FormalReturnTypeFlow(position, returnType)); } @@ -501,7 +499,7 @@ private void createTypeFlow() { parameter = new FormalReceiverTypeFlow(AbstractAnalysisEngine.sourcePosition(node), paramType); } else { int offset = isStatic ? 0 : 1; - AnalysisType paramType = (AnalysisType) method.getSignature().getParameterType(index - offset, method.getDeclaringClass()); + AnalysisType paramType = method.getSignature().getParameterType(index - offset); parameter = new FormalParamTypeFlow(AbstractAnalysisEngine.sourcePosition(node), paramType, index); } flowsGraph.setParameter(index, parameter); @@ -772,7 +770,7 @@ class NodeIterator extends PostOrderNodeIterator { */ private TypeFlowBuilder uniqueReturnFlowBuilder(ReturnNode node) { if (returnBuilder == null) { - AnalysisType returnType = (AnalysisType) method.getSignature().getReturnType(method.getDeclaringClass()); + AnalysisType returnType = method.getSignature().getReturnType(); if (bb.isSupportedJavaKind(returnType.getJavaKind())) { returnBuilder = TypeFlowBuilder.create(bb, node, FormalReturnTypeFlow.class, () -> { FormalReturnTypeFlow returnFlow = flowsGraph.getReturnFlow(); @@ -1538,7 +1536,7 @@ protected void processMethodInvocation(TypeFlowsOfNodes state, ValueNode invoke, if (!createDeoptInvokeTypeFlow && bb.isSupportedJavaKind(invoke.asNode().getStackKind())) { /* Create the actual return builder. */ - AnalysisType returnType = (AnalysisType) targetMethod.getSignature().getReturnType(null); + AnalysisType returnType = targetMethod.getSignature().getReturnType(); TypeFlowBuilder actualReturnBuilder = TypeFlowBuilder.create(bb, invoke.asNode(), ActualReturnTypeFlow.class, () -> { InvokeTypeFlow invokeFlow = invokeBuilder.get(); ActualReturnTypeFlow actualReturn = new ActualReturnTypeFlow(invokeFlow.source, returnType); diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/infrastructure/GraphProvider.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/infrastructure/GraphProvider.java index f4c3ef594311..0d8d99e9ec34 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/infrastructure/GraphProvider.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/infrastructure/GraphProvider.java @@ -24,11 +24,11 @@ */ package com.oracle.graal.pointsto.infrastructure; +import com.oracle.graal.pointsto.meta.AnalysisMethod; import com.oracle.graal.pointsto.meta.HostedProviders; import jdk.graal.compiler.debug.DebugContext; import jdk.graal.compiler.nodes.StructuredGraph; -import jdk.vm.ci.meta.ResolvedJavaMethod; public interface GraphProvider { enum Purpose { @@ -36,7 +36,7 @@ enum Purpose { PREPARE_RUNTIME_COMPILATION, } - StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose); + StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose); /** * Returns true if a graph can be provided for {@link Purpose#PREPARE_RUNTIME_COMPILATION}. Note diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/infrastructure/ResolvedSignature.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/infrastructure/ResolvedSignature.java index 173ef1962207..4b55a2df1a2d 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/infrastructure/ResolvedSignature.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/infrastructure/ResolvedSignature.java @@ -93,6 +93,11 @@ public int getParameterCount(boolean withReceiver) { return parameterTypes.size() + (withReceiver ? 1 : 0); } + /* + * Use the version without the accessingClass when calling methods directly on + * ResolvedSignature. + */ + @Deprecated @Override public T getParameterType(int index, ResolvedJavaType accessingClass) { return getParameterType(index); @@ -102,6 +107,11 @@ public T getParameterType(int index) { return parameterTypes.get(index); } + /* + * Use the version without the accessingClass when calling methods directly on + * ResolvedSignature. + */ + @Deprecated @Override public T getReturnType(ResolvedJavaType accessingClass) { return getReturnType(); diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/AnalysisMethod.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/AnalysisMethod.java index 108cb2b118e6..d360780d45ac 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/AnalysisMethod.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/AnalysisMethod.java @@ -72,6 +72,7 @@ import jdk.graal.compiler.nodes.graphbuilderconf.InvocationPlugin; import jdk.vm.ci.code.Architecture; import jdk.vm.ci.code.BytecodePosition; +import jdk.vm.ci.common.JVMCIError; import jdk.vm.ci.meta.Constant; import jdk.vm.ci.meta.ConstantPool; import jdk.vm.ci.meta.ExceptionHandler; @@ -221,7 +222,6 @@ protected AnalysisMethod(AnalysisUniverse universe, ResolvedJavaMethod wrapped, if (PointstoOptions.TrackAccessChain.getValue(declaringClass.universe.hostVM().options())) { startTrackInvocations(); } - registerSignatureTypes(); parsingContextMaxDepth = PointstoOptions.ParsingContextMaxDepth.getValue(declaringClass.universe.hostVM.options()); } @@ -257,22 +257,6 @@ private static String createName(ResolvedJavaMethod wrapped, MultiMethodKey mult return aName; } - /** - * Lookup the parameters and return type so that they are added to the universe even if the - * method is never linked and parsed. - */ - private void registerSignatureTypes() { - boolean isStatic = Modifier.isStatic(getModifiers()); - int parameterCount = getSignature().getParameterCount(!isStatic); - - int offset = isStatic ? 0 : 1; - for (int i = offset; i < parameterCount; i++) { - getSignature().getParameterType(i - offset, getDeclaringClass()); - } - - getSignature().getReturnType(getDeclaringClass()); - } - public String getQualifiedName() { return qualifiedName; } @@ -630,22 +614,31 @@ public String getName() { } @Override - public jdk.vm.ci.meta.Signature getSignature() { + public ResolvedSignature getSignature() { return signature; } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { - if (wrapped instanceof GraphProvider) { - return ((GraphProvider) wrapped).buildGraph(debug, method, providers, purpose); + public JavaType[] toParameterTypes() { + throw JVMCIError.shouldNotReachHere("ResolvedJavaMethod.toParameterTypes returns the wrong result for constructors. Use toParameterList instead."); + } + + public List toParameterList() { + return getSignature().toParameterList(isStatic() ? null : getDeclaringClass()); + } + + @Override + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { + if (wrapped instanceof GraphProvider graphProvider) { + return graphProvider.buildGraph(debug, method, providers, purpose); } return null; } @Override public boolean allowRuntimeCompilation() { - if (wrapped instanceof GraphProvider) { - return ((GraphProvider) wrapped).allowRuntimeCompilation(); + if (wrapped instanceof GraphProvider graphProvider) { + return graphProvider.allowRuntimeCompilation(); } return true; } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/AnalysisType.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/AnalysisType.java index 66c0cbc87dfd..d7f368549859 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/AnalysisType.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/AnalysisType.java @@ -40,7 +40,6 @@ import java.util.function.Consumer; import java.util.function.Function; -import jdk.graal.compiler.debug.GraalError; import org.graalvm.nativeimage.hosted.Feature.DuringAnalysisAccess; import org.graalvm.word.WordBase; @@ -64,6 +63,7 @@ import com.oracle.svm.util.LogUtils; import com.oracle.svm.util.UnsafePartitionKind; +import jdk.graal.compiler.debug.GraalError; import jdk.vm.ci.code.BytecodePosition; import jdk.vm.ci.meta.Assumptions.AssumptionResult; import jdk.vm.ci.meta.JavaConstant; @@ -899,7 +899,7 @@ public final JavaKind getJavaKind() { } @Override - public final AnalysisType resolve(ResolvedJavaType accessingClass) { + public final ResolvedJavaType resolve(ResolvedJavaType accessingClass) { return this; } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/PointsToAnalysisMethod.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/PointsToAnalysisMethod.java index d5eafbf9689e..65fb8401e5a7 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/PointsToAnalysisMethod.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/PointsToAnalysisMethod.java @@ -195,10 +195,10 @@ private static InvokeTypeFlow createContextInsensitiveInvoke(PointsToAnalysis bb actualParameters[0] = receiverFlow; for (int i = 1; i < actualParameters.length; i++) { - actualParameters[i] = new ActualParameterTypeFlow((AnalysisType) method.getSignature().getParameterType(i - 1, null)); + actualParameters[i] = new ActualParameterTypeFlow(method.getSignature().getParameterType(i - 1)); } ActualReturnTypeFlow actualReturn = null; - AnalysisType returnType = (AnalysisType) method.getSignature().getReturnType(null); + AnalysisType returnType = method.getSignature().getReturnType(); if (bb.isSupportedJavaKind(returnType.getStorageKind())) { actualReturn = new ActualReturnTypeFlow(returnType); } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/phases/InlineBeforeAnalysisGraphDecoder.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/phases/InlineBeforeAnalysisGraphDecoder.java index 17cfc981e4db..308b33edc49c 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/phases/InlineBeforeAnalysisGraphDecoder.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/phases/InlineBeforeAnalysisGraphDecoder.java @@ -32,6 +32,16 @@ import java.util.concurrent.ConcurrentHashMap; import org.graalvm.collections.EconomicSet; + +import com.oracle.graal.pointsto.BigBang; +import com.oracle.graal.pointsto.flow.AnalysisParsedGraph; +import com.oracle.graal.pointsto.meta.AnalysisField; +import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.HostedProviders; +import com.oracle.graal.pointsto.util.AnalysisError; +import com.oracle.graal.pointsto.util.GraalAccess; +import com.oracle.svm.util.ReflectionUtil; + import jdk.graal.compiler.bytecode.BytecodeProvider; import jdk.graal.compiler.debug.GraalError; import jdk.graal.compiler.graph.Node; @@ -59,16 +69,6 @@ import jdk.graal.compiler.replacements.PEGraphDecoder; import jdk.graal.compiler.replacements.nodes.MethodHandleWithExceptionNode; import jdk.graal.compiler.replacements.nodes.ResolvedMethodHandleCallTargetNode; - -import com.oracle.graal.pointsto.BigBang; -import com.oracle.graal.pointsto.flow.AnalysisParsedGraph; -import com.oracle.graal.pointsto.meta.AnalysisField; -import com.oracle.graal.pointsto.meta.AnalysisMethod; -import com.oracle.graal.pointsto.meta.HostedProviders; -import com.oracle.graal.pointsto.util.AnalysisError; -import com.oracle.graal.pointsto.util.GraalAccess; -import com.oracle.svm.util.ReflectionUtil; - import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.ResolvedJavaField; import jdk.vm.ci.meta.ResolvedJavaMethod; @@ -88,7 +88,7 @@ public class InlineBeforeAnalysisMethodScope extends PEMethodScope { */ private final EconomicSet encodedGraphs; - InlineBeforeAnalysisMethodScope(StructuredGraph targetGraph, PEMethodScope caller, LoopScope callerLoopScope, EncodedGraph encodedGraph, ResolvedJavaMethod method, + InlineBeforeAnalysisMethodScope(StructuredGraph targetGraph, PEMethodScope caller, LoopScope callerLoopScope, EncodedGraph encodedGraph, AnalysisMethod method, InvokeData invokeData, int inliningDepth, ValueNode[] arguments) { super(targetGraph, caller, callerLoopScope, encodedGraph, method, invokeData, inliningDepth, arguments); @@ -166,7 +166,7 @@ protected void cleanupGraph(MethodScope ms) { @Override protected PEMethodScope createMethodScope(StructuredGraph targetGraph, PEMethodScope caller, LoopScope callerLoopScope, EncodedGraph encodedGraph, ResolvedJavaMethod method, InvokeData invokeData, int inliningDepth, ValueNode[] arguments) { - return new InlineBeforeAnalysisMethodScope(targetGraph, caller, callerLoopScope, encodedGraph, method, invokeData, inliningDepth, arguments); + return new InlineBeforeAnalysisMethodScope(targetGraph, caller, callerLoopScope, encodedGraph, (AnalysisMethod) method, invokeData, inliningDepth, arguments); } @Override @@ -205,7 +205,7 @@ protected final Node canonicalizeFixedNode(MethodScope methodScope, LoopScope lo @Override protected boolean shouldOmitIntermediateMethodInStates(ResolvedJavaMethod method) { - return policy.shouldOmitIntermediateMethodInState(method); + return policy.shouldOmitIntermediateMethodInState((AnalysisMethod) method); } @SuppressWarnings("unused") @@ -312,7 +312,7 @@ protected void maybeAbortInlining(MethodScope ms, @SuppressWarnings("unused") Lo if (graph.getDebug().isLogEnabled()) { graph.getDebug().logv(" ".repeat(methodScope.inliningDepth) + " node " + node + ": " + methodScope.policyScope); } - if (!methodScope.policyScope.processNode(bb.getMetaAccess(), methodScope.method, node)) { + if (!methodScope.policyScope.processNode(bb.getMetaAccess(), (AnalysisMethod) methodScope.method, node)) { abortInlining(methodScope); } } @@ -502,6 +502,6 @@ protected InlineBeforeAnalysisMethodScope cast(MethodScope methodScope) { protected FixedWithNextNode afterMethodScopeCreation(PEMethodScope is, FixedWithNextNode predecessor) { InlineBeforeAnalysisMethodScope inlineScope = cast(is); var sourcePosition = inlineScope.invokeData.invoke.asNode().getNodeSourcePosition(); - return policy.processInvokeArgs(inlineScope.method, predecessor, inlineScope.getArguments(), sourcePosition); + return policy.processInvokeArgs((AnalysisMethod) inlineScope.method, predecessor, inlineScope.getArguments(), sourcePosition); } } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/phases/InlineBeforeAnalysisInlineInvokePlugin.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/phases/InlineBeforeAnalysisInlineInvokePlugin.java index a4cbd9a2ea3b..d24fe0429d9e 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/phases/InlineBeforeAnalysisInlineInvokePlugin.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/phases/InlineBeforeAnalysisInlineInvokePlugin.java @@ -24,10 +24,11 @@ */ package com.oracle.graal.pointsto.phases; +import com.oracle.graal.pointsto.meta.AnalysisMethod; + import jdk.graal.compiler.nodes.ValueNode; import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderContext; import jdk.graal.compiler.nodes.graphbuilderconf.InlineInvokePlugin; - import jdk.vm.ci.meta.ResolvedJavaMethod; final class InlineBeforeAnalysisInlineInvokePlugin implements InlineInvokePlugin { @@ -39,7 +40,8 @@ final class InlineBeforeAnalysisInlineInvokePlugin implements InlineInvokePlugin } @Override - public InlineInfo shouldInlineInvoke(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args) { + public InlineInfo shouldInlineInvoke(GraphBuilderContext b, ResolvedJavaMethod m, ValueNode[] args) { + AnalysisMethod method = (AnalysisMethod) m; if (policy.shouldInlineInvoke(b, method, args)) { return policy.createInvokeInfo(method); } else { diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/phases/InlineBeforeAnalysisPolicy.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/phases/InlineBeforeAnalysisPolicy.java index 0f9af9a140d2..c13fad407ee2 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/phases/InlineBeforeAnalysisPolicy.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/phases/InlineBeforeAnalysisPolicy.java @@ -24,6 +24,10 @@ */ package com.oracle.graal.pointsto.phases; +import com.oracle.graal.pointsto.meta.AnalysisMetaAccess; +import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.util.AnalysisError; + import jdk.graal.compiler.graph.Node; import jdk.graal.compiler.graph.NodeSourcePosition; import jdk.graal.compiler.nodes.FixedWithNextNode; @@ -32,11 +36,6 @@ import jdk.graal.compiler.nodes.graphbuilderconf.InlineInvokePlugin.InlineInfo; import jdk.graal.compiler.nodes.graphbuilderconf.NodePlugin; -import com.oracle.graal.pointsto.meta.AnalysisMetaAccess; -import com.oracle.graal.pointsto.util.AnalysisError; - -import jdk.vm.ci.meta.ResolvedJavaMethod; - /** * Provides the policy which methods are inlined by {@link InlineBeforeAnalysis}. If * {@link #shouldInlineInvoke} returns true for an invocation, the graph decoding goes into callees @@ -77,7 +76,7 @@ protected AbstractPolicyScope(int inliningDepth) { * available. But usages have not been decoded yet, so the implementation must not base any * decision on the current list of usages. The list of usages is often but not always empty. */ - public abstract boolean processNode(AnalysisMetaAccess metaAccess, ResolvedJavaMethod method, Node node); + public abstract boolean processNode(AnalysisMetaAccess metaAccess, AnalysisMethod method, Node node); } protected final NodePlugin[] nodePlugins; @@ -86,35 +85,35 @@ protected InlineBeforeAnalysisPolicy(NodePlugin[] nodePlugins) { this.nodePlugins = nodePlugins; } - protected abstract boolean shouldInlineInvoke(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args); + protected abstract boolean shouldInlineInvoke(GraphBuilderContext b, AnalysisMethod method, ValueNode[] args); - protected abstract InlineInfo createInvokeInfo(ResolvedJavaMethod method); + protected abstract InlineInfo createInvokeInfo(AnalysisMethod method); protected abstract boolean needsExplicitExceptions(); protected abstract boolean tryInvocationPlugins(); - protected abstract FixedWithNextNode processInvokeArgs(ResolvedJavaMethod targetMethod, FixedWithNextNode insertionPoint, ValueNode[] arguments, NodeSourcePosition sourcePosition); + protected abstract FixedWithNextNode processInvokeArgs(AnalysisMethod targetMethod, FixedWithNextNode insertionPoint, ValueNode[] arguments, NodeSourcePosition sourcePosition); protected abstract AbstractPolicyScope createRootScope(); protected abstract AbstractPolicyScope openCalleeScope(AbstractPolicyScope outer, AnalysisMetaAccess metaAccess, - ResolvedJavaMethod method, boolean[] constArgsWithReceiver, boolean intrinsifiedMethodHandle); + AnalysisMethod method, boolean[] constArgsWithReceiver, boolean intrinsifiedMethodHandle); /** @see InlineBeforeAnalysisGraphDecoder#shouldOmitIntermediateMethodInStates */ - protected boolean shouldOmitIntermediateMethodInState(ResolvedJavaMethod method) { + protected boolean shouldOmitIntermediateMethodInState(AnalysisMethod method) { return false; } public static final InlineBeforeAnalysisPolicy NO_INLINING = new InlineBeforeAnalysisPolicy(new NodePlugin[0]) { @Override - protected boolean shouldInlineInvoke(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args) { + protected boolean shouldInlineInvoke(GraphBuilderContext b, AnalysisMethod method, ValueNode[] args) { return false; } @Override - protected InlineInfo createInvokeInfo(ResolvedJavaMethod method) { + protected InlineInfo createInvokeInfo(AnalysisMethod method) { throw AnalysisError.shouldNotReachHere("NO_INLINING policy should not try to inline"); } @@ -133,7 +132,7 @@ protected boolean tryInvocationPlugins() { } @Override - protected FixedWithNextNode processInvokeArgs(ResolvedJavaMethod targetMethod, FixedWithNextNode insertionPoint, ValueNode[] arguments, NodeSourcePosition sourcePosition) { + protected FixedWithNextNode processInvokeArgs(AnalysisMethod targetMethod, FixedWithNextNode insertionPoint, ValueNode[] arguments, NodeSourcePosition sourcePosition) { throw AnalysisError.shouldNotReachHere("NO_INLINING policy should not try to inline"); } @@ -145,7 +144,7 @@ protected AbstractPolicyScope createRootScope() { @Override protected AbstractPolicyScope openCalleeScope(AbstractPolicyScope outer, AnalysisMetaAccess metaAccess, - ResolvedJavaMethod method, boolean[] constArgsWithReceiver, boolean intrinsifiedMethodHandle) { + AnalysisMethod method, boolean[] constArgsWithReceiver, boolean intrinsifiedMethodHandle) { throw AnalysisError.shouldNotReachHere("NO_INLINING policy should not try to inline"); } }; diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/reports/CallTreePrinter.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/reports/CallTreePrinter.java index 74a1a0cedf72..d1e53852971f 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/reports/CallTreePrinter.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/reports/CallTreePrinter.java @@ -57,17 +57,15 @@ import java.util.stream.Collectors; import java.util.stream.Stream; -import jdk.graal.compiler.java.LambdaUtils; - import com.oracle.graal.pointsto.BigBang; import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.AnalysisType; import com.oracle.graal.pointsto.meta.InvokeInfo; import com.oracle.graal.pointsto.util.AnalysisError; +import jdk.graal.compiler.java.LambdaUtils; import jdk.vm.ci.code.BytecodePosition; import jdk.vm.ci.meta.JavaKind; -import jdk.vm.ci.meta.ResolvedJavaMethod; -import jdk.vm.ci.meta.ResolvedJavaType; public final class CallTreePrinter { @@ -315,7 +313,7 @@ private static void printCallTreeNode(PrintWriter out, String prefix, MethodNode private void printUsedMethods(PrintWriter out) { List methodsList = new ArrayList<>(); - for (ResolvedJavaMethod method : methodToNode.keySet()) { + for (AnalysisMethod method : methodToNode.keySet()) { methodsList.add(method.format("%H.%n(%p):%r")); } methodsList.sort(null); @@ -334,7 +332,7 @@ private void printClasses(PrintWriter out, boolean packageNameOnly) { public Set classesSet(boolean packageNameOnly) { Set classSet = new HashSet<>(); - for (ResolvedJavaMethod method : methodToNode.keySet()) { + for (AnalysisMethod method : methodToNode.keySet()) { String name = method.getDeclaringClass().toJavaName(true); if (packageNameOnly) { name = packagePrefix(name); @@ -536,7 +534,7 @@ private static List virtualMethodInfo(AnalysisMethod method) { return resolvedJavaMethodInfo(null, method); } - private static List resolvedJavaMethodInfo(Integer id, ResolvedJavaMethod method) { + private static List resolvedJavaMethodInfo(Integer id, AnalysisMethod method) { // TODO method parameter types are opaque, but could in the future be split out and link // together // e.g. each method could BELONG to a type, and a method could have PARAMETER relationships @@ -552,13 +550,13 @@ private static List resolvedJavaMethodInfo(Integer id, ResolvedJavaMetho method.getName(), method.getDeclaringClass().toJavaName(true), parameters, - method.getSignature().getReturnType(null).toJavaName(true), + method.getSignature().getReturnType().toJavaName(true), display(method), flags(method)); } - private static String display(ResolvedJavaMethod method) { - final ResolvedJavaType type = method.getDeclaringClass(); + private static String display(AnalysisMethod method) { + final AnalysisType type = method.getDeclaringClass(); final String typeName = type.toJavaName(true); if (type.getJavaKind() == JavaKind.Object) { List matchResults = new ArrayList<>(); @@ -573,7 +571,7 @@ private static String display(ResolvedJavaMethod method) { return typeName + "." + method.getName(); } - private static String flags(ResolvedJavaMethod method) { + private static String flags(AnalysisMethod method) { StringBuilder sb = new StringBuilder(); if (method.isPublic()) { sb.append('p'); diff --git a/substratevm/src/com.oracle.graal.reachability/src/com/oracle/graal/reachability/DirectMethodProcessingHandler.java b/substratevm/src/com.oracle.graal.reachability/src/com/oracle/graal/reachability/DirectMethodProcessingHandler.java index e168faffdea1..149d33ca0267 100644 --- a/substratevm/src/com.oracle.graal.reachability/src/com/oracle/graal/reachability/DirectMethodProcessingHandler.java +++ b/substratevm/src/com.oracle.graal.reachability/src/com/oracle/graal/reachability/DirectMethodProcessingHandler.java @@ -27,6 +27,12 @@ import java.lang.reflect.Modifier; import java.util.Optional; +import org.graalvm.nativeimage.AnnotationAccess; + +import com.oracle.graal.pointsto.AbstractAnalysisEngine; +import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.svm.common.meta.MultiMethod; + import jdk.graal.compiler.core.common.spi.ForeignCallDescriptor; import jdk.graal.compiler.core.common.spi.ForeignCallSignature; import jdk.graal.compiler.core.common.spi.ForeignCallsProvider; @@ -48,12 +54,6 @@ import jdk.graal.compiler.replacements.nodes.BinaryMathIntrinsicNode; import jdk.graal.compiler.replacements.nodes.MacroInvokable; import jdk.graal.compiler.replacements.nodes.UnaryMathIntrinsicNode; -import org.graalvm.nativeimage.AnnotationAccess; - -import com.oracle.graal.pointsto.AbstractAnalysisEngine; -import com.oracle.graal.pointsto.meta.AnalysisMethod; -import com.oracle.svm.common.meta.MultiMethod; - import jdk.vm.ci.code.BytecodePosition; import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.ResolvedJavaMethod; @@ -82,11 +82,11 @@ private static void analyzeStructuredGraph(ReachabilityAnalysisEngine bb, Reacha int parameterCount = method.getSignature().getParameterCount(!isStatic); int offset = isStatic ? 0 : 1; for (int i = offset; i < parameterCount; i++) { - bb.registerTypeAsReachable((ReachabilityAnalysisType) method.getSignature().getParameterType(i - offset, method.getDeclaringClass()), + bb.registerTypeAsReachable(method.getSignature().getParameterType(i - offset), "Parameter type for " + method.format("%H.%n(%p)")); } - bb.registerTypeAsReachable((ReachabilityAnalysisType) method.getSignature().getReturnType(method.getDeclaringClass()), "Return type for " + method.format("%H.%n(%p)")); + bb.registerTypeAsReachable(method.getSignature().getReturnType(), "Return type for " + method.format("%H.%n(%p)")); } for (Node n : graph.getNodes()) { diff --git a/substratevm/src/com.oracle.graal.reachability/src/com/oracle/graal/reachability/SimpleInMemoryMethodSummaryProvider.java b/substratevm/src/com.oracle.graal.reachability/src/com/oracle/graal/reachability/SimpleInMemoryMethodSummaryProvider.java index 2009522063ea..a8797640f858 100644 --- a/substratevm/src/com.oracle.graal.reachability/src/com/oracle/graal/reachability/SimpleInMemoryMethodSummaryProvider.java +++ b/substratevm/src/com.oracle.graal.reachability/src/com/oracle/graal/reachability/SimpleInMemoryMethodSummaryProvider.java @@ -28,6 +28,14 @@ import java.util.Optional; import org.graalvm.collections.EconomicSet; +import org.graalvm.nativeimage.AnnotationAccess; + +import com.oracle.graal.pointsto.AbstractAnalysisEngine; +import com.oracle.graal.pointsto.meta.AnalysisField; +import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.AnalysisType; +import com.oracle.svm.common.meta.MultiMethod; + import jdk.graal.compiler.core.common.spi.ForeignCallDescriptor; import jdk.graal.compiler.core.common.spi.ForeignCallSignature; import jdk.graal.compiler.core.common.spi.ForeignCallsProvider; @@ -49,14 +57,6 @@ import jdk.graal.compiler.replacements.nodes.BinaryMathIntrinsicNode; import jdk.graal.compiler.replacements.nodes.MacroInvokable; import jdk.graal.compiler.replacements.nodes.UnaryMathIntrinsicNode; -import org.graalvm.nativeimage.AnnotationAccess; - -import com.oracle.graal.pointsto.AbstractAnalysisEngine; -import com.oracle.graal.pointsto.meta.AnalysisField; -import com.oracle.graal.pointsto.meta.AnalysisMethod; -import com.oracle.graal.pointsto.meta.AnalysisType; -import com.oracle.svm.common.meta.MultiMethod; - import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.ResolvedJavaType; @@ -94,10 +94,10 @@ private static MethodSummary createSummaryFromGraph(ReachabilityAnalysisEngine b int parameterCount = method.getSignature().getParameterCount(!isStatic); int offset = isStatic ? 0 : 1; for (int i = offset; i < parameterCount; i++) { - accessedTypes.add((ReachabilityAnalysisType) method.getSignature().getParameterType(i - offset, method.getDeclaringClass())); + accessedTypes.add(method.getSignature().getParameterType(i - offset)); } - accessedTypes.add((ReachabilityAnalysisType) method.getSignature().getReturnType(method.getDeclaringClass())); + accessedTypes.add(method.getSignature().getReturnType()); } for (Node n : graph.getNodes()) { diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/replacements/SubstrateGraphKit.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/replacements/SubstrateGraphKit.java index 16388d5513c1..6ce0a602447c 100644 --- a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/replacements/SubstrateGraphKit.java +++ b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/replacements/SubstrateGraphKit.java @@ -25,6 +25,7 @@ package com.oracle.svm.core.graal.replacements; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import com.oracle.svm.core.graal.code.SubstrateCallingConventionKind; @@ -95,6 +96,7 @@ public class SubstrateGraphKit extends GraphKit { private final FrameStateBuilder frameState; private int nextBCI; + private final List arguments; @SuppressWarnings("this-escape") public SubstrateGraphKit(DebugContext debug, ResolvedJavaMethod stubMethod, Providers providers, @@ -104,7 +106,9 @@ public SubstrateGraphKit(DebugContext debug, ResolvedJavaMethod stubMethod, Prov frameState = new FrameStateBuilder(this, stubMethod, graph); frameState.disableKindVerification(); frameState.disableStateVerification(); - frameState.initializeForMethodStart(null, true, graphBuilderPlugins); + List collectedArguments = new ArrayList<>(); + frameState.initializeForMethodStart(null, true, graphBuilderPlugins, collectedArguments); + arguments = Collections.unmodifiableList(collectedArguments); graph.start().setStateAfter(frameState.create(bci(), graph.start())); } @@ -133,21 +137,7 @@ public void storeLocal(int index, JavaKind slotKind, ValueNode value) { frameState.storeLocal(index, slotKind, value); } - public List loadArguments(JavaType[] paramTypes) { - List arguments = new ArrayList<>(); - int numOfParams = paramTypes.length; - int javaIndex = 0; - - for (int i = 0; i < numOfParams; i++) { - JavaType type = paramTypes[i]; - JavaKind kind = type.getJavaKind(); - - assert frameState.loadLocal(javaIndex, kind) != null; - arguments.add(frameState.loadLocal(javaIndex, kind)); - - javaIndex += kind.getSlotCount(); - } - + public List getInitialArguments() { return arguments; } @@ -387,15 +377,9 @@ protected T appendWithUnwind(T withExceptionNode, return withExceptionNode; } - public void appendStateSplitProxy(FrameState state) { - StateSplitProxyNode proxy = new StateSplitProxyNode(); - append(proxy); - proxy.setStateAfter(state); - } - - public void appendStateSplitProxy(FrameStateBuilder stateBuilder) { + public void appendStateSplitProxy() { StateSplitProxyNode proxy = new StateSplitProxyNode(); append(proxy); - proxy.setStateAfter(stateBuilder.create(bci(), proxy)); + proxy.setStateAfter(frameState.create(bci(), proxy)); } } diff --git a/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/hosted/GraalGraphObjectReplacer.java b/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/hosted/GraalGraphObjectReplacer.java index a9e45602485b..cc3ed6852370 100644 --- a/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/hosted/GraalGraphObjectReplacer.java +++ b/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/hosted/GraalGraphObjectReplacer.java @@ -34,6 +34,7 @@ import com.oracle.graal.pointsto.constraints.UnsupportedFeatureException; import com.oracle.graal.pointsto.heap.ImageHeapConstant; +import com.oracle.graal.pointsto.infrastructure.ResolvedSignature; import com.oracle.graal.pointsto.meta.AnalysisField; import com.oracle.graal.pointsto.meta.AnalysisMethod; import com.oracle.graal.pointsto.meta.AnalysisType; @@ -88,7 +89,6 @@ import jdk.vm.ci.meta.ResolvedJavaField; import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.ResolvedJavaType; -import jdk.vm.ci.meta.Signature; /** * Replaces Graal related objects during analysis in the universe. @@ -106,7 +106,7 @@ public static class Options { private final ConcurrentMap fields = new ConcurrentHashMap<>(); private final ConcurrentMap fieldLocationIdentities = new ConcurrentHashMap<>(); private final ConcurrentMap types = new ConcurrentHashMap<>(); - private final ConcurrentMap signatures = new ConcurrentHashMap<>(); + private final ConcurrentMap, SubstrateSignature> signatures = new ConcurrentHashMap<>(); private final SubstrateProviders sProviders; private final SubstrateUniverseFactory universeFactory; private SubstrateGraalRuntime sGraalRuntime; @@ -369,9 +369,7 @@ private SubstrateField[] createAllInstanceFields(ResolvedJavaType originalType) return sFields; } - private synchronized SubstrateSignature createSignature(Signature original) { - assert !(original instanceof SubstrateSignature) : original; - + private synchronized SubstrateSignature createSignature(ResolvedSignature original) { SubstrateSignature sSignature = signatures.get(original); if (sSignature == null) { SubstrateSignature newSignature = new SubstrateSignature(); @@ -381,13 +379,13 @@ private synchronized SubstrateSignature createSignature(Signature original) { SubstrateType[] parameterTypes = new SubstrateType[original.getParameterCount(false)]; for (int index = 0; index < original.getParameterCount(false); index++) { - parameterTypes[index] = createType(original.getParameterType(index, null)); + parameterTypes[index] = createType(original.getParameterType(index)); } /* * The links to other meta objects must be set after adding to the signatures to * avoid infinite recursion. */ - sSignature.setTypes(parameterTypes, createType(original.getReturnType(null))); + sSignature.setTypes(parameterTypes, createType(original.getReturnType())); } } return sSignature; diff --git a/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/hosted/ParseOnceRuntimeCompilationFeature.java b/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/hosted/ParseOnceRuntimeCompilationFeature.java index 849a5928a849..a77c64d41a88 100644 --- a/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/hosted/ParseOnceRuntimeCompilationFeature.java +++ b/substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/hosted/ParseOnceRuntimeCompilationFeature.java @@ -1010,7 +1010,7 @@ protected boolean needsExplicitExceptions() { } @Override - protected FixedWithNextNode processInvokeArgs(ResolvedJavaMethod targetMethod, FixedWithNextNode insertionPoint, ValueNode[] arguments, NodeSourcePosition sourcePosition) { + protected FixedWithNextNode processInvokeArgs(AnalysisMethod targetMethod, FixedWithNextNode insertionPoint, ValueNode[] arguments, NodeSourcePosition sourcePosition) { StructuredGraph graph = insertionPoint.graph(); InlinedInvokeArgumentsNode newNode = graph.add(new InlinedInvokeArgumentsNode(targetMethod, arguments)); newNode.setNodeSourcePosition(sourcePosition); @@ -1019,7 +1019,7 @@ protected FixedWithNextNode processInvokeArgs(ResolvedJavaMethod targetMethod, F } @Override - protected boolean shouldInlineInvoke(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args) { + protected boolean shouldInlineInvoke(GraphBuilderContext b, AnalysisMethod method, ValueNode[] args) { if (inliningUtils.alwaysInlineInvoke((AnalysisMetaAccess) b.getMetaAccess(), method)) { return true; } @@ -1042,13 +1042,13 @@ protected boolean shouldInlineInvoke(GraphBuilderContext b, ResolvedJavaMethod m } @Override - protected InlineInvokePlugin.InlineInfo createInvokeInfo(ResolvedJavaMethod method) { + protected InlineInvokePlugin.InlineInfo createInvokeInfo(AnalysisMethod method) { /* * Set this graph initially to a stub. If there are no explicit calls to this method * (i.e., all calls to this method are inlined), then the method's full flow will not * need to be created. */ - AnalysisMethod runtimeMethod = ((AnalysisMethod) method).getOrCreateMultiMethod(RUNTIME_COMPILED_METHOD, (newMethod) -> ((PointsToAnalysisMethod) newMethod).getTypeFlow().setAsStubFlow()); + AnalysisMethod runtimeMethod = method.getOrCreateMultiMethod(RUNTIME_COMPILED_METHOD, (newMethod) -> ((PointsToAnalysisMethod) newMethod).getTypeFlow().setAsStubFlow()); return InlineInvokePlugin.InlineInfo.createStandardInlineInfo(runtimeMethod); } @@ -1060,7 +1060,7 @@ protected AbstractPolicyScope createRootScope() { @Override protected AbstractPolicyScope openCalleeScope(AbstractPolicyScope outer, AnalysisMetaAccess metaAccess, - ResolvedJavaMethod method, boolean[] constArgsWithReceiver, boolean intrinsifiedMethodHandle) { + AnalysisMethod method, boolean[] constArgsWithReceiver, boolean intrinsifiedMethodHandle) { if (outer instanceof AccumulativeInlineScope accOuter) { /* * once the accumulative policy is activated, then we cannot return to the trivial @@ -1072,7 +1072,7 @@ protected AbstractPolicyScope openCalleeScope(AbstractPolicyScope outer, Analysi assert outer == null || outer instanceof AlwaysInlineScope : "unexpected outer scope: " + outer; // check if trivial is possible - boolean trivialInlineAllowed = hostVM.isAnalysisTrivialMethod((AnalysisMethod) method); + boolean trivialInlineAllowed = hostVM.isAnalysisTrivialMethod(method); int inliningDepth = outer == null ? 1 : outer.inliningDepth + 1; if (trivialInlineAllowed && inliningDepth <= trivialAllowingInliningDepth) { return new AlwaysInlineScope(inliningDepth); diff --git a/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/DowncallStub.java b/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/DowncallStub.java index 044a42b381b5..b124ca82cde9 100644 --- a/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/DowncallStub.java +++ b/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/DowncallStub.java @@ -26,15 +26,12 @@ import java.util.List; -import jdk.graal.compiler.core.common.spi.ForeignCallDescriptor; -import jdk.graal.compiler.debug.DebugContext; -import jdk.graal.compiler.java.FrameStateBuilder; -import jdk.graal.compiler.nodes.StructuredGraph; -import jdk.graal.compiler.nodes.ValueNode; import org.graalvm.nativeimage.Platform; import org.graalvm.nativeimage.Platforms; import org.graalvm.nativeimage.c.function.CFunction; +import com.oracle.graal.pointsto.infrastructure.ResolvedSignature; +import com.oracle.graal.pointsto.meta.AnalysisMethod; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.common.meta.MultiMethod; import com.oracle.svm.core.foreign.AbiUtils; @@ -48,12 +45,15 @@ import com.oracle.svm.core.graal.snippets.CFunctionSnippets; import com.oracle.svm.core.thread.VMThreads; import com.oracle.svm.hosted.code.NonBytecodeMethod; -import com.oracle.svm.hosted.code.SimpleSignature; import com.oracle.svm.util.ReflectionUtil; +import jdk.graal.compiler.core.common.spi.ForeignCallDescriptor; +import jdk.graal.compiler.debug.DebugContext; +import jdk.graal.compiler.java.FrameStateBuilder; +import jdk.graal.compiler.nodes.StructuredGraph; +import jdk.graal.compiler.nodes.ValueNode; import jdk.vm.ci.meta.JavaKind; import jdk.vm.ci.meta.MetaAccessProvider; -import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.Signature; /** @@ -86,7 +86,7 @@ @Platforms(Platform.HOSTED_ONLY.class) class DowncallStub extends NonBytecodeMethod { public static Signature createSignature(MetaAccessProvider metaAccess) { - return SimpleSignature.fromKinds(new JavaKind[]{JavaKind.Object}, JavaKind.Object, metaAccess); + return ResolvedSignature.fromKinds(new JavaKind[]{JavaKind.Object}, JavaKind.Object, metaAccess); } private final NativeEntryPointInfo nep; @@ -106,11 +106,11 @@ public static Signature createSignature(MetaAccessProvider metaAccess) { * {@link LinkToNativeSupportImpl#linkToNative(Object...)}. */ @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { ForeignGraphKit kit = new ForeignGraphKit(debug, providers, method, purpose); FrameStateBuilder state = kit.getFrameState(); boolean deoptimizationTarget = MultiMethod.isDeoptTarget(method); - List arguments = kit.loadArguments(getSignature().toParameterTypes(null)); + List arguments = kit.getInitialArguments(); assert arguments.size() == 1; var argumentsAndNep = kit.unpackArgumentsAndExtractNEP(arguments.get(0), nep.methodType()); @@ -139,7 +139,7 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, ValueNode returnValue = kit.createCFunctionCallWithCapture( callAddress, adapted.arguments(), - SimpleSignature.fromMethodType(adapted.callType(), kit.getMetaAccess()), + ResolvedSignature.fromMethodType(adapted.callType(), kit.getMetaAccess()), VMThreads.StatusSupport.getNewThreadStatus(transition), deoptimizationTarget, cc, diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/cenum/CEnumCallWrapperMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/cenum/CEnumCallWrapperMethod.java index a7946c3648a2..2cea176fbfc5 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/cenum/CEnumCallWrapperMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/cenum/CEnumCallWrapperMethod.java @@ -29,6 +29,8 @@ import org.graalvm.nativeimage.c.constant.CEnumLookup; import org.graalvm.nativeimage.c.constant.CEnumValue; +import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.AnalysisType; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.core.util.VMError; import com.oracle.svm.hosted.annotation.CustomSubstitutionMethod; @@ -72,15 +74,13 @@ public boolean isSynthetic() { } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { - + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { HostedGraphKit kit = new HostedGraphKit(debug, providers, method); - StructuredGraph graph = kit.getGraph(); - ResolvedJavaType returnType = (ResolvedJavaType) method.getSignature().getReturnType(null); - ValueNode arg = kit.loadArguments(method.toParameterTypes()).get(0); + AnalysisType returnType = method.getSignature().getReturnType(); + ValueNode arg = kit.getInitialArguments().get(0); - CInterfaceEnumTool tool = new CInterfaceEnumTool(providers.getMetaAccess(), providers.getSnippetReflection()); + CInterfaceEnumTool tool = new CInterfaceEnumTool(kit.getMetaAccess(), kit.getSnippetReflection()); JavaKind pushKind = CInterfaceInvocationPlugin.pushKind(method); ValueNode returnValue; @@ -93,9 +93,9 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, EnumInfo enumInfo = (EnumInfo) nativeLibraries.findElementInfo(declaringType); ValueNode invoke = tool.createEnumValueInvoke(kit, enumInfo, returnType.getJavaKind(), arg); - ValueNode adapted = CInterfaceInvocationPlugin.adaptPrimitiveType(graph, invoke, invoke.stamp(NodeView.DEFAULT).getStackKind(), returnType.getJavaKind(), false); + ValueNode adapted = CInterfaceInvocationPlugin.adaptPrimitiveType(kit.getGraph(), invoke, invoke.stamp(NodeView.DEFAULT).getStackKind(), returnType.getJavaKind(), false); Stamp originalStamp = StampFactory.forKind(returnType.getJavaKind()); - returnValue = CInterfaceInvocationPlugin.adaptPrimitiveType(graph, adapted, returnType.getJavaKind(), originalStamp.getStackKind(), false); + returnValue = CInterfaceInvocationPlugin.adaptPrimitiveType(kit.getGraph(), adapted, returnType.getJavaKind(), originalStamp.getStackKind(), false); } else { throw VMError.shouldNotReachHereUnexpectedInput(method); // ExcludeFromJacocoGeneratedReport } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/classinitialization/SimulateClassInitializerPolicy.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/classinitialization/SimulateClassInitializerPolicy.java index e1b48fc71639..e697a824b451 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/classinitialization/SimulateClassInitializerPolicy.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/classinitialization/SimulateClassInitializerPolicy.java @@ -24,10 +24,10 @@ */ package com.oracle.svm.hosted.classinitialization; -import jdk.graal.compiler.graph.NodeSourcePosition; import org.graalvm.nativeimage.AnnotationAccess; import com.oracle.graal.pointsto.meta.AnalysisMetaAccess; +import com.oracle.graal.pointsto.meta.AnalysisMethod; import com.oracle.graal.pointsto.phases.InlineBeforeAnalysis; import com.oracle.graal.pointsto.phases.InlineBeforeAnalysisPolicy; import com.oracle.svm.core.ParsingReason; @@ -37,12 +37,12 @@ import com.oracle.svm.hosted.phases.InlineBeforeAnalysisPolicyUtils; import jdk.graal.compiler.graph.Node; +import jdk.graal.compiler.graph.NodeSourcePosition; import jdk.graal.compiler.nodes.FixedWithNextNode; import jdk.graal.compiler.nodes.ValueNode; import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderContext; import jdk.graal.compiler.nodes.graphbuilderconf.InlineInvokePlugin; import jdk.graal.compiler.nodes.graphbuilderconf.NodePlugin; -import jdk.vm.ci.meta.ResolvedJavaMethod; /** * This class is necessary because simulation of class initializer is based on @@ -87,7 +87,7 @@ public void abortCalleeScope(InlineBeforeAnalysisPolicy.AbstractPolicyScope call } @Override - public boolean processNode(AnalysisMetaAccess metaAccess, ResolvedJavaMethod method, Node node) { + public boolean processNode(AnalysisMetaAccess metaAccess, AnalysisMethod method, Node node) { return true; } @@ -108,7 +108,7 @@ public String toString() { } @Override - protected boolean shouldInlineInvoke(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args) { + protected boolean shouldInlineInvoke(GraphBuilderContext b, AnalysisMethod method, ValueNode[] args) { if (b.getDepth() > support.maxInlineDepth) { /* Safeguard against excessive inlining, for example endless recursion. */ return false; @@ -135,12 +135,12 @@ protected boolean needsExplicitExceptions() { } @Override - protected InlineInvokePlugin.InlineInfo createInvokeInfo(ResolvedJavaMethod method) { + protected InlineInvokePlugin.InlineInfo createInvokeInfo(AnalysisMethod method) { return InlineInvokePlugin.InlineInfo.createStandardInlineInfo(method); } @Override - protected FixedWithNextNode processInvokeArgs(ResolvedJavaMethod targetMethod, FixedWithNextNode insertionPoint, ValueNode[] arguments, NodeSourcePosition sourcePosition) { + protected FixedWithNextNode processInvokeArgs(AnalysisMethod targetMethod, FixedWithNextNode insertionPoint, ValueNode[] arguments, NodeSourcePosition sourcePosition) { // No action is needed return insertionPoint; } @@ -155,7 +155,7 @@ protected AbstractPolicyScope createRootScope() { @Override protected AbstractPolicyScope openCalleeScope(AbstractPolicyScope o, AnalysisMetaAccess metaAccess, - ResolvedJavaMethod method, boolean[] constArgsWithReceiver, boolean intrinsifiedMethodHandle) { + AnalysisMethod method, boolean[] constArgsWithReceiver, boolean intrinsifiedMethodHandle) { var outer = (SimulateClassInitializerInlineScope) o; return new SimulateClassInitializerInlineScope(outer.accumulativeCounters, outer.inliningDepth + 1); } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CCallStubMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CCallStubMethod.java index 1ae0c7087cdd..54e23a7debda 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CCallStubMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CCallStubMethod.java @@ -24,11 +24,15 @@ */ package com.oracle.svm.hosted.code; +import java.util.ArrayList; import java.util.List; import org.graalvm.nativeimage.c.constant.CEnum; import org.graalvm.nativeimage.c.constant.CEnumLookup; +import com.oracle.graal.pointsto.infrastructure.ResolvedSignature; +import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.AnalysisType; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.common.meta.MultiMethod; import com.oracle.svm.core.util.UserError; @@ -46,10 +50,7 @@ import jdk.graal.compiler.nodes.ValueNode; import jdk.vm.ci.meta.JavaKind; import jdk.vm.ci.meta.JavaType; -import jdk.vm.ci.meta.MetaAccessProvider; import jdk.vm.ci.meta.ResolvedJavaMethod; -import jdk.vm.ci.meta.ResolvedJavaType; -import jdk.vm.ci.meta.Signature; public abstract class CCallStubMethod extends CustomSubstitutionMethod { private static final JavaKind cEnumKind = JavaKind.Int; @@ -64,47 +65,42 @@ public abstract class CCallStubMethod extends CustomSubstitutionMethod { protected abstract String getCorrespondingAnnotationName(); @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { NativeLibraries nativeLibraries = CEntryPointCallStubSupport.singleton().getNativeLibraries(); boolean deoptimizationTarget = MultiMethod.isDeoptTarget(method); HostedGraphKit kit = new HostedGraphKit(debug, providers, method); FrameStateBuilder state = kit.getFrameState(); - List arguments = kit.loadArguments(getParameterTypesForLoad(method)); - ValueNode callAddress = createTargetAddressNode(kit, providers, arguments); - Signature signature = adaptSignatureAndConvertArguments(providers, nativeLibraries, kit, method, - method.getSignature().getReturnType(null), method.toParameterTypes(), arguments); + List arguments = new ArrayList<>(kit.getInitialArguments()); + ValueNode callAddress = createTargetAddressNode(kit, arguments); + AnalysisType[] paramTypes = method.toParameterList().toArray(AnalysisType[]::new); + var signature = adaptSignatureAndConvertArguments(nativeLibraries, kit, method, method.getSignature().getReturnType(), paramTypes, arguments); state.clearLocals(); ValueNode returnValue = kit.createCFunctionCall(callAddress, arguments, signature, newThreadStatus, deoptimizationTarget); - returnValue = adaptReturnValue(method, providers, nativeLibraries, kit, returnValue); + returnValue = adaptReturnValue(method, nativeLibraries, kit, returnValue); kit.createReturn(returnValue, signature.getReturnKind()); return kit.finalizeGraph(); } - protected abstract ValueNode createTargetAddressNode(HostedGraphKit kit, HostedProviders providers, List arguments); + protected abstract ValueNode createTargetAddressNode(HostedGraphKit kit, List arguments); - protected static boolean isPrimitiveOrWord(HostedProviders providers, JavaType type) { - return type.getJavaKind().isPrimitive() || providers.getWordTypes().isWord(type); + protected static boolean isPrimitiveOrWord(HostedGraphKit kit, JavaType type) { + return type.getJavaKind().isPrimitive() || kit.getWordTypes().isWord(type); } - protected JavaType[] getParameterTypesForLoad(ResolvedJavaMethod method) { - return method.getSignature().toParameterTypes(/* exclude receiver parameter */ null); - } - - protected Signature adaptSignatureAndConvertArguments(HostedProviders providers, NativeLibraries nativeLibraries, - HostedGraphKit kit, @SuppressWarnings("unused") ResolvedJavaMethod method, JavaType returnType, JavaType[] parameterTypes, List arguments) { + protected ResolvedSignature adaptSignatureAndConvertArguments(NativeLibraries nativeLibraries, + HostedGraphKit kit, @SuppressWarnings("unused") AnalysisMethod method, AnalysisType returnType, AnalysisType[] parameterTypes, List arguments) { - MetaAccessProvider metaAccess = providers.getMetaAccess(); for (int i = 0; i < parameterTypes.length; i++) { - if (!isPrimitiveOrWord(providers, parameterTypes[i])) { - ElementInfo typeInfo = nativeLibraries.findElementInfo((ResolvedJavaType) parameterTypes[i]); + if (!isPrimitiveOrWord(kit, parameterTypes[i])) { + ElementInfo typeInfo = nativeLibraries.findElementInfo(parameterTypes[i]); if (typeInfo instanceof EnumInfo) { ValueNode argumentValue = kit.maybeCreateExplicitNullCheck(arguments.get(i)); - CInterfaceEnumTool tool = new CInterfaceEnumTool(metaAccess, providers.getSnippetReflection()); + CInterfaceEnumTool tool = new CInterfaceEnumTool(kit.getMetaAccess(), kit.getSnippetReflection()); argumentValue = tool.createEnumValueInvoke(kit, (EnumInfo) typeInfo, cEnumKind, argumentValue); arguments.set(i, argumentValue); - parameterTypes[i] = metaAccess.lookupJavaType(cEnumKind.toJavaClass()); + parameterTypes[i] = kit.getMetaAccess().lookupJavaType(cEnumKind.toJavaClass()); } else { throw UserError.abort("@%s parameter types are restricted to primitive types, word types and enumerations (@%s): %s", getCorrespondingAnnotationName(), CEnum.class.getSimpleName(), getOriginal()); @@ -112,17 +108,17 @@ protected Signature adaptSignatureAndConvertArguments(HostedProviders providers, } } /* Actual checks and conversion are in adaptReturnValue() */ - JavaType actualReturnType = isPrimitiveOrWord(providers, returnType) ? returnType : providers.getWordTypes().getWordImplType(); - return new SimpleSignature(parameterTypes, actualReturnType); + AnalysisType actualReturnType = isPrimitiveOrWord(kit, returnType) ? returnType : (AnalysisType) kit.getWordTypes().getWordImplType(); + return ResolvedSignature.fromArray(parameterTypes, actualReturnType); } - private ValueNode adaptReturnValue(ResolvedJavaMethod method, HostedProviders providers, NativeLibraries nativeLibraries, HostedGraphKit kit, ValueNode invokeValue) { + private ValueNode adaptReturnValue(AnalysisMethod method, NativeLibraries nativeLibraries, HostedGraphKit kit, ValueNode invokeValue) { ValueNode returnValue = invokeValue; - JavaType declaredReturnType = method.getSignature().getReturnType(null); - if (isPrimitiveOrWord(providers, declaredReturnType)) { + AnalysisType declaredReturnType = method.getSignature().getReturnType(); + if (isPrimitiveOrWord(kit, declaredReturnType)) { return returnValue; } - ElementInfo typeInfo = nativeLibraries.findElementInfo((ResolvedJavaType) declaredReturnType); + ElementInfo typeInfo = nativeLibraries.findElementInfo(declaredReturnType); if (typeInfo instanceof EnumInfo) { UserError.guarantee(typeInfo.getChildren().stream().anyMatch(EnumLookupInfo.class::isInstance), "Enum class %s needs a method that is annotated with @%s because it is used as the return type of a method annotated with @%s: %s", @@ -133,8 +129,8 @@ private ValueNode adaptReturnValue(ResolvedJavaMethod method, HostedProviders pr // We take a word return type because checks expect word type replacements, but it is // narrowed to cEnumKind here. - CInterfaceEnumTool tool = new CInterfaceEnumTool(providers.getMetaAccess(), providers.getSnippetReflection()); - returnValue = tool.createEnumLookupInvoke(kit, (ResolvedJavaType) declaredReturnType, (EnumInfo) typeInfo, cEnumKind, returnValue); + CInterfaceEnumTool tool = new CInterfaceEnumTool(kit.getMetaAccess(), kit.getSnippetReflection()); + returnValue = tool.createEnumLookupInvoke(kit, declaredReturnType, (EnumInfo) typeInfo, cEnumKind, returnValue); } else { throw UserError.abort("Return types of methods annotated with @%s are restricted to primitive types, word types and enumerations (@%s): %s", getCorrespondingAnnotationName(), CEnum.class.getSimpleName(), getOriginal()); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CEntryPointCallStubMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CEntryPointCallStubMethod.java index ef4a6ae5eee6..71065a6d71a5 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CEntryPointCallStubMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CEntryPointCallStubMethod.java @@ -25,8 +25,9 @@ package com.oracle.svm.hosted.code; import java.lang.annotation.Annotation; -import java.util.Arrays; +import java.util.ArrayList; import java.util.Iterator; +import java.util.List; import org.graalvm.nativeimage.Isolate; import org.graalvm.nativeimage.IsolateThread; @@ -36,6 +37,7 @@ import org.graalvm.nativeimage.c.function.CEntryPoint.IsolateContext; import org.graalvm.nativeimage.c.function.CEntryPoint.IsolateThreadContext; +import com.oracle.graal.pointsto.infrastructure.ResolvedSignature; import com.oracle.graal.pointsto.meta.AnalysisMetaAccess; import com.oracle.graal.pointsto.meta.AnalysisMethod; import com.oracle.graal.pointsto.meta.AnalysisType; @@ -84,11 +86,9 @@ import jdk.vm.ci.code.BytecodeFrame; import jdk.vm.ci.meta.ConstantPool; import jdk.vm.ci.meta.JavaKind; -import jdk.vm.ci.meta.JavaType; import jdk.vm.ci.meta.MetaAccessProvider; import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.ResolvedJavaType; -import jdk.vm.ci.meta.Signature; public final class CEntryPointCallStubMethod extends EntryPointCallStubMethod { static CEntryPointCallStubMethod create(AnalysisMethod targetMethod, CEntryPointData entryPointData, AnalysisMetaAccess aMetaAccess) { @@ -102,7 +102,7 @@ static CEntryPointCallStubMethod create(AnalysisMethod targetMethod, CEntryPoint private final CEntryPointData entryPointData; private final ResolvedJavaMethod targetMethod; - private final Signature targetSignature; + private final ResolvedSignature targetSignature; private CEntryPointCallStubMethod(CEntryPointData entryPointData, AnalysisMethod targetMethod, ResolvedJavaType holderClass, ConstantPool holderConstantPool, JavaKind wordKind, MetaAccessProvider metaAccess) { @@ -119,20 +119,18 @@ private CEntryPointCallStubMethod(CEntryPointData entryPointData, AnalysisMethod * return type is transformed into the word type. * * @see CEnum - * @see CEntryPointCallStubMethod#adaptParameterTypes(HostedProviders, NativeLibraries, - * HostedGraphKit, JavaType[], JavaType[]) - * @see CEntryPointCallStubMethod#adaptReturnValue(HostedProviders, HostedGraphKit, ValueNode) + * @see CEntryPointCallStubMethod#adaptParameterTypes + * @see CEntryPointCallStubMethod#adaptReturnValue(HostedGraphKit, ValueNode) */ - private static SimpleSignature createSignature(AnalysisMethod targetMethod, JavaKind wordKind, MetaAccessProvider metaAccess) { - JavaType[] paramTypes = Arrays.stream(targetMethod.toParameterTypes()) - .map(it -> ((AnalysisType) it)) + private static ResolvedSignature createSignature(AnalysisMethod targetMethod, JavaKind wordKind, MetaAccessProvider metaAccess) { + ResolvedJavaType[] paramTypes = targetMethod.toParameterList().stream() .map(type -> type.getAnnotation(CEnum.class) != null ? metaAccess.lookupJavaType(cEnumParameterKind.toJavaClass()) : type.getWrapped()) - .toArray(JavaType[]::new); - ResolvedJavaType returnType = ((AnalysisType) targetMethod.getSignature().getReturnType(null)).getWrapped(); + .toArray(ResolvedJavaType[]::new); + ResolvedJavaType returnType = targetMethod.getSignature().getReturnType().getWrapped(); if (returnType.getAnnotation(CEnum.class) != null) { returnType = metaAccess.lookupJavaType(wordKind.toJavaClass()); } - return new SimpleSignature(paramTypes, returnType); + return ResolvedSignature.fromArray(paramTypes, returnType); } @Override @@ -145,24 +143,23 @@ AnalysisMethod lookupTargetMethod(AnalysisMetaAccess metaAccess) { } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { if (entryPointData.getBuiltin() != CEntryPointData.DEFAULT_BUILTIN) { return buildBuiltinGraph(debug, method, providers); } - AnalysisMetaAccess aMetaAccess = (AnalysisMetaAccess) providers.getMetaAccess(); - NativeLibraries nativeLibraries = CEntryPointCallStubSupport.singleton().getNativeLibraries(); HostedGraphKit kit = new HostedGraphKit(debug, providers, method); + NativeLibraries nativeLibraries = CEntryPointCallStubSupport.singleton().getNativeLibraries(); - JavaType[] parameterTypes = targetSignature.toParameterTypes(null); - JavaType[] parameterLoadTypes = Arrays.copyOf(parameterTypes, parameterTypes.length); + List parameterTypes = new ArrayList<>(targetSignature.toParameterList(null)); + List parameterLoadTypes = new ArrayList<>(parameterTypes); EnumInfo[] parameterEnumInfos; - parameterEnumInfos = adaptParameterTypes(providers, nativeLibraries, kit, parameterTypes, parameterLoadTypes); + parameterEnumInfos = adaptParameterTypes(nativeLibraries, kit, parameterTypes, parameterLoadTypes); - ValueNode[] args = kit.loadArguments(parameterLoadTypes).toArray(ValueNode.EMPTY_ARRAY); + ValueNode[] args = kit.getInitialArguments().toArray(ValueNode.EMPTY_ARRAY); - InvokeWithExceptionNode invokePrologue = generatePrologue(providers, kit, parameterLoadTypes, targetMethod.getParameterAnnotations(), args); + InvokeWithExceptionNode invokePrologue = generatePrologue(kit, parameterLoadTypes, targetMethod.getParameterAnnotations(), args); if (invokePrologue != null) { ResolvedJavaMethod prologueMethod = invokePrologue.callTarget().targetMethod(); JavaKind prologueReturnKind = prologueMethod.getSignature().getReturnKind(); @@ -187,7 +184,7 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, } if (!createdReturnNode) { - ResolvedJavaMethod[] bailoutMethods = providers.getMetaAccess().lookupJavaType(bailoutCustomizer).getDeclaredMethods(false); + AnalysisMethod[] bailoutMethods = kit.getMetaAccess().lookupJavaType(bailoutCustomizer).getDeclaredMethods(false); UserError.guarantee(bailoutMethods.length == 1 && bailoutMethods[0].isStatic(), "Prologue bailout customization class must declare exactly one static method: %s -> %s", targetMethod, bailoutCustomizer); @@ -203,9 +200,9 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, } } - adaptArgumentValues(providers, kit, parameterTypes, parameterEnumInfos, args); + adaptArgumentValues(kit, parameterTypes, parameterEnumInfos, args); - AnalysisMethod aTargetMethod = aMetaAccess.getUniverse().lookup(targetMethod); + AnalysisMethod aTargetMethod = kit.getMetaAccess().getUniverse().lookup(targetMethod); kit.emitEnsureInitializedCall(aTargetMethod.getDeclaringClass()); int invokeBci = kit.bci(); @@ -221,16 +218,16 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, patchNodeSourcePosition(invoke); kit.exceptionPart(); ExceptionObjectNode exception = kit.exceptionObject(); - generateExceptionHandler(providers, kit, exception, invoke.getStackKind()); + generateExceptionHandler(kit, exception, invoke.getStackKind()); kit.endInvokeWithException(); - generateEpilogueAndReturn(providers, kit, invoke); + generateEpilogueAndReturn(kit, invoke); return kit.finalizeGraph(); } - private void generateEpilogueAndReturn(HostedProviders providers, HostedGraphKit kit, ValueNode value) { - ValueNode returnValue = adaptReturnValue(providers, kit, value); - generateEpilogue(providers, kit); + private void generateEpilogueAndReturn(HostedGraphKit kit, ValueNode value) { + ValueNode returnValue = adaptReturnValue(kit, value); + generateEpilogue(kit); kit.createReturn(returnValue, returnValue.getStackKind()); } @@ -241,9 +238,9 @@ private static void patchNodeSourcePosition(InvokeWithExceptionNode invoke) { } } - private StructuredGraph buildBuiltinGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers) { - AnalysisMetaAccess aMetaAccess = (AnalysisMetaAccess) providers.getMetaAccess(); - AnalysisMethod aTargetMethod = aMetaAccess.getUniverse().lookup(targetMethod); + private StructuredGraph buildBuiltinGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers) { + HostedGraphKit kit = new HostedGraphKit(debug, providers, method); + AnalysisMethod aTargetMethod = kit.getMetaAccess().getUniverse().lookup(targetMethod); UserError.guarantee(entryPointData.getPrologue() == CEntryPointData.DEFAULT_PROLOGUE, "@%s method declared as built-in must not have a custom prologue: %s", CEntryPoint.class.getSimpleName(), aTargetMethod); @@ -252,13 +249,11 @@ private StructuredGraph buildBuiltinGraph(DebugContext debug, ResolvedJavaMethod UserError.guarantee(entryPointData.getExceptionHandler() == CEntryPointData.DEFAULT_EXCEPTION_HANDLER, "@%s method declared as built-in must not have a custom exception handler: %s", CEntryPoint.class.getSimpleName(), aTargetMethod); - HostedGraphKit kit = new HostedGraphKit(debug, providers, method); - - ExecutionContextParameters executionContext = findExecutionContextParameters(providers, aTargetMethod.toParameterTypes(), aTargetMethod.getParameterAnnotations()); + ExecutionContextParameters executionContext = findExecutionContextParameters(kit, aTargetMethod.toParameterList(), aTargetMethod.getParameterAnnotations()); final CEntryPoint.Builtin builtin = entryPointData.getBuiltin(); - ResolvedJavaMethod builtinCallee = null; - for (ResolvedJavaMethod candidate : aMetaAccess.lookupJavaType(CEntryPointBuiltins.class).getDeclaredMethods(false)) { + AnalysisMethod builtinCallee = null; + for (AnalysisMethod candidate : kit.getMetaAccess().lookupJavaType(CEntryPointBuiltins.class).getDeclaredMethods(false)) { CEntryPointBuiltinImplementation annotation = candidate.getAnnotation(CEntryPointBuiltinImplementation.class); if (annotation != null && annotation.builtin().equals(builtin)) { VMError.guarantee(builtinCallee == null, "More than one candidate for @%s built-in %s", CEntryPoint.class.getSimpleName(), builtin); @@ -267,13 +262,13 @@ private StructuredGraph buildBuiltinGraph(DebugContext debug, ResolvedJavaMethod } VMError.guarantee(builtinCallee != null, "No candidate for @%s built-in %s", CEntryPoint.class.getSimpleName(), builtin); - ResolvedJavaType isolateType = providers.getMetaAccess().lookupJavaType(Isolate.class); - ResolvedJavaType threadType = providers.getMetaAccess().lookupJavaType(IsolateThread.class); + AnalysisType isolateType = kit.getMetaAccess().lookupJavaType(Isolate.class); + AnalysisType threadType = kit.getMetaAccess().lookupJavaType(IsolateThread.class); int builtinIsolateIndex = -1; int builtinThreadIndex = -1; - JavaType[] builtinParamTypes = builtinCallee.toParameterTypes(); - for (int i = 0; i < builtinParamTypes.length; i++) { - ResolvedJavaType type = (ResolvedJavaType) builtinParamTypes[i]; + List builtinParamTypes = builtinCallee.toParameterList(); + for (int i = 0; i < builtinParamTypes.size(); i++) { + AnalysisType type = builtinParamTypes.get(i); if (isolateType.isAssignableFrom(type)) { VMError.guarantee(builtinIsolateIndex == -1, "@%s built-in with more than one %s parameter: %s", CEntryPoint.class.getSimpleName(), Isolate.class.getSimpleName(), builtinCallee); @@ -288,9 +283,9 @@ private StructuredGraph buildBuiltinGraph(DebugContext debug, ResolvedJavaMethod } } - ValueNode[] args = kit.loadArguments(method.toParameterTypes()).toArray(ValueNode.EMPTY_ARRAY); + ValueNode[] args = kit.getInitialArguments().toArray(ValueNode.EMPTY_ARRAY); - ValueNode[] builtinArgs = new ValueNode[builtinParamTypes.length]; + ValueNode[] builtinArgs = new ValueNode[builtinParamTypes.size()]; if (builtinIsolateIndex != -1) { VMError.guarantee(executionContext.designatedIsolateIndex != -1 || executionContext.isolateCount == 1, "@%s built-in %s needs exactly one %s parameter: %s", CEntryPoint.class.getSimpleName(), entryPointData.getBuiltin(), Isolate.class.getSimpleName(), builtinCallee); @@ -309,7 +304,7 @@ private StructuredGraph buildBuiltinGraph(DebugContext debug, ResolvedJavaMethod kit.exceptionPart(); ExceptionObjectNode exception = kit.exceptionObject(); - generateExceptionHandler(providers, kit, exception, invoke.getStackKind()); + generateExceptionHandler(kit, exception, invoke.getStackKind()); kit.endInvokeWithException(); kit.createReturn(invoke, aTargetMethod.getSignature().getReturnKind()); @@ -317,26 +312,24 @@ private StructuredGraph buildBuiltinGraph(DebugContext debug, ResolvedJavaMethod return kit.finalizeGraph(); } - private EnumInfo[] adaptParameterTypes(HostedProviders providers, NativeLibraries nativeLibraries, HostedGraphKit kit, - JavaType[] parameterTypes, JavaType[] parameterLoadTypes) { - + private EnumInfo[] adaptParameterTypes(NativeLibraries nativeLibraries, HostedGraphKit kit, List parameterTypes, List parameterLoadTypes) { EnumInfo[] parameterEnumInfos = null; - for (int i = 0; i < parameterTypes.length; i++) { - if (!parameterTypes[i].getJavaKind().isPrimitive() && !providers.getWordTypes().isWord(parameterTypes[i])) { - ElementInfo typeInfo = nativeLibraries.findElementInfo((ResolvedJavaType) parameterTypes[i]); + for (int i = 0; i < parameterTypes.size(); i++) { + if (!parameterTypes.get(i).getJavaKind().isPrimitive() && !kit.getWordTypes().isWord(parameterTypes.get(i))) { + ElementInfo typeInfo = nativeLibraries.findElementInfo(parameterTypes.get(i)); if (typeInfo instanceof EnumInfo) { UserError.guarantee(typeInfo.getChildren().stream().anyMatch(EnumLookupInfo.class::isInstance), "Enum class %s needs a method that is annotated with @%s because it is used as a parameter of an entry point method: %s", - parameterTypes[i], + parameterTypes.get(i), CEnumLookup.class.getSimpleName(), targetMethod); if (parameterEnumInfos == null) { - parameterEnumInfos = new EnumInfo[parameterTypes.length]; + parameterEnumInfos = new EnumInfo[parameterTypes.size()]; } parameterEnumInfos[i] = (EnumInfo) typeInfo; - parameterLoadTypes[i] = providers.getMetaAccess().lookupJavaType(cEnumParameterKind.toJavaClass()); + parameterLoadTypes.set(i, kit.getMetaAccess().lookupJavaType(cEnumParameterKind.toJavaClass())); final int parameterIndex = i; FrameState initialState = kit.getGraph().start().stateAfter(); @@ -346,26 +339,26 @@ private EnumInfo[] adaptParameterTypes(HostedProviders providers, NativeLibrarie parameterNode.setStamp(StampFactory.forKind(cEnumParameterKind)); } else { throw UserError.abort("Entry point method parameter types are restricted to primitive types, word types and enumerations (@%s): %s, given type was %s", - CEnum.class.getSimpleName(), targetMethod, parameterTypes[i]); + CEnum.class.getSimpleName(), targetMethod, parameterTypes.get(i)); } } } return parameterEnumInfos; } - private static void adaptArgumentValues(HostedProviders providers, HostedGraphKit kit, JavaType[] parameterTypes, EnumInfo[] parameterEnumInfos, ValueNode[] args) { + private static void adaptArgumentValues(HostedGraphKit kit, List parameterTypes, EnumInfo[] parameterEnumInfos, ValueNode[] args) { if (parameterEnumInfos != null) { // These methods must be called after the prologue established a safe context for (int i = 0; i < parameterEnumInfos.length; i++) { if (parameterEnumInfos[i] != null) { - CInterfaceEnumTool tool = new CInterfaceEnumTool(providers.getMetaAccess(), providers.getSnippetReflection()); - args[i] = tool.createEnumLookupInvoke(kit, (ResolvedJavaType) parameterTypes[i], parameterEnumInfos[i], cEnumParameterKind, args[i]); + CInterfaceEnumTool tool = new CInterfaceEnumTool(kit.getMetaAccess(), kit.getSnippetReflection()); + args[i] = tool.createEnumLookupInvoke(kit, parameterTypes.get(i), parameterEnumInfos[i], cEnumParameterKind, args[i]); } } } } - private InvokeWithExceptionNode generatePrologue(HostedProviders providers, SubstrateGraphKit kit, JavaType[] parameterTypes, Annotation[][] parameterAnnotations, ValueNode[] args) { + private InvokeWithExceptionNode generatePrologue(HostedGraphKit kit, List parameterTypes, Annotation[][] parameterAnnotations, ValueNode[] args) { Class prologueClass = entryPointData.getPrologue(); if (prologueClass == NoPrologue.class) { UserError.guarantee(Uninterruptible.Utils.isUninterruptible(targetMethod), @@ -377,20 +370,20 @@ private InvokeWithExceptionNode generatePrologue(HostedProviders providers, Subs return null; } if (prologueClass != CEntryPointOptions.AutomaticPrologue.class) { - ResolvedJavaType prologue = providers.getMetaAccess().lookupJavaType(prologueClass); - ResolvedJavaMethod[] prologueMethods = prologue.getDeclaredMethods(false); + AnalysisType prologue = kit.getMetaAccess().lookupJavaType(prologueClass); + AnalysisMethod[] prologueMethods = prologue.getDeclaredMethods(false); UserError.guarantee(prologueMethods.length == 1 && prologueMethods[0].isStatic(), "Prologue class must declare exactly one static method: %s -> %s", targetMethod, prologue); UserError.guarantee(Uninterruptible.Utils.isUninterruptible(prologueMethods[0]), "Prologue method must be annotated with @%s: %s", Uninterruptible.class.getSimpleName(), prologueMethods[0]); - ValueNode[] prologueArgs = matchPrologueParameters(providers, parameterTypes, args, prologueMethods[0]); + ValueNode[] prologueArgs = matchPrologueParameters(kit, parameterTypes, args, prologueMethods[0]); return generatePrologueOrEpilogueInvoke(kit, prologueMethods[0], prologueArgs); } // Automatically choose prologue from signature and annotations and call - ExecutionContextParameters executionContext = findExecutionContextParameters(providers, parameterTypes, parameterAnnotations); + ExecutionContextParameters executionContext = findExecutionContextParameters(kit, parameterTypes, parameterAnnotations); int contextIndex = -1; if (executionContext.designatedThreadIndex != -1) { contextIndex = executionContext.designatedThreadIndex; @@ -402,12 +395,12 @@ private InvokeWithExceptionNode generatePrologue(HostedProviders providers, Subs } ValueNode contextValue = args[contextIndex]; prologueClass = CEntryPointSetup.EnterPrologue.class; - ResolvedJavaMethod[] prologueMethods = providers.getMetaAccess().lookupJavaType(prologueClass).getDeclaredMethods(false); + AnalysisMethod[] prologueMethods = kit.getMetaAccess().lookupJavaType(prologueClass).getDeclaredMethods(false); assert prologueMethods.length == 1 && prologueMethods[0].isStatic() : "Prologue class must declare exactly one static method"; return generatePrologueOrEpilogueInvoke(kit, prologueMethods[0], contextValue); } - private static InvokeWithExceptionNode generatePrologueOrEpilogueInvoke(SubstrateGraphKit kit, ResolvedJavaMethod method, ValueNode... args) { + private static InvokeWithExceptionNode generatePrologueOrEpilogueInvoke(SubstrateGraphKit kit, AnalysisMethod method, ValueNode... args) { VMError.guarantee(Uninterruptible.Utils.isUninterruptible(method), "The method %s must be uninterruptible as it is used for a prologue or epilogue.", method); InvokeWithExceptionNode invoke = kit.startInvokeWithException(method, InvokeKind.Static, kit.getFrameState(), kit.bci(), args); kit.exceptionPart(); @@ -426,13 +419,13 @@ private static class ExecutionContextParameters { int designatedThreadIndex = -1; } - private ExecutionContextParameters findExecutionContextParameters(HostedProviders providers, JavaType[] parameterTypes, Annotation[][] parameterAnnotations) { - ResolvedJavaType isolateType = providers.getMetaAccess().lookupJavaType(Isolate.class); - ResolvedJavaType threadType = providers.getMetaAccess().lookupJavaType(IsolateThread.class); + private ExecutionContextParameters findExecutionContextParameters(HostedGraphKit kit, List parameterTypes, Annotation[][] parameterAnnotations) { + AnalysisType isolateType = kit.getMetaAccess().lookupJavaType(Isolate.class); + AnalysisType threadType = kit.getMetaAccess().lookupJavaType(IsolateThread.class); ExecutionContextParameters result = new ExecutionContextParameters(); - for (int i = 0; i < parameterTypes.length; i++) { - ResolvedJavaType declaredType = (ResolvedJavaType) parameterTypes[i]; + for (int i = 0; i < parameterTypes.size(); i++) { + AnalysisType declaredType = parameterTypes.get(i); boolean isIsolate = isolateType.isAssignableFrom(declaredType); boolean isThread = threadType.isAssignableFrom(declaredType); boolean isLong = declaredType.getJavaKind() == JavaKind.Long; @@ -486,20 +479,19 @@ private ExecutionContextParameters findExecutionContextParameters(HostedProvider return result; } - private ValueNode[] matchPrologueParameters(HostedProviders providers, JavaType[] types, ValueNode[] values, ResolvedJavaMethod prologueMethod) { - JavaType[] prologueTypes = prologueMethod.toParameterTypes(); - ValueNode[] prologueValues = new ValueNode[prologueTypes.length]; + private ValueNode[] matchPrologueParameters(HostedGraphKit kit, List types, ValueNode[] values, AnalysisMethod prologueMethod) { + ValueNode[] prologueValues = new ValueNode[prologueMethod.getSignature().getParameterCount(false)]; int i = 0; - for (int p = 0; p < prologueTypes.length; p++) { - ResolvedJavaType prologueType = (ResolvedJavaType) prologueTypes[p]; - UserError.guarantee(prologueType.isPrimitive() || providers.getWordTypes().isWord(prologueType), + for (int p = 0; p < prologueValues.length; p++) { + AnalysisType prologueType = prologueMethod.getSignature().getParameterType(p); + UserError.guarantee(prologueType.isPrimitive() || kit.getWordTypes().isWord(prologueType), "Prologue method parameter types are restricted to primitive types and word types: %s -> %s", targetMethod, prologueMethod); - while (i < types.length && !prologueType.isAssignableFrom((ResolvedJavaType) types[i])) { + while (i < types.size() && !prologueType.isAssignableFrom(types.get(i))) { i++; } - if (i >= types.length) { + if (i >= types.size()) { throw UserError.abort("Unable to match signature of entry point method to that of prologue method: %s -> %s", targetMethod, prologueMethod); @@ -510,22 +502,22 @@ private ValueNode[] matchPrologueParameters(HostedProviders providers, JavaType[ return prologueValues; } - private void generateExceptionHandler(HostedProviders providers, HostedGraphKit kit, ExceptionObjectNode exception, JavaKind returnKind) { + private void generateExceptionHandler(HostedGraphKit kit, ExceptionObjectNode exception, JavaKind returnKind) { if (entryPointData.getExceptionHandler() == CEntryPoint.FatalExceptionHandler.class) { CEntryPointLeaveNode leave = new CEntryPointLeaveNode(LeaveAction.ExceptionAbort, exception); kit.append(leave); kit.append(new LoweredDeadEndNode()); } else { - ResolvedJavaType throwable = providers.getMetaAccess().lookupJavaType(Throwable.class); - ResolvedJavaType handler = providers.getMetaAccess().lookupJavaType(entryPointData.getExceptionHandler()); - ResolvedJavaMethod[] handlerMethods = handler.getDeclaredMethods(false); + AnalysisType throwable = kit.getMetaAccess().lookupJavaType(Throwable.class); + AnalysisType handler = kit.getMetaAccess().lookupJavaType(entryPointData.getExceptionHandler()); + AnalysisMethod[] handlerMethods = handler.getDeclaredMethods(false); UserError.guarantee(handlerMethods.length == 1 && handlerMethods[0].isStatic(), "Exception handler class must declare exactly one static method: %s -> %s", targetMethod, handler); UserError.guarantee(Uninterruptible.Utils.isUninterruptible(handlerMethods[0]), "Exception handler method must be annotated with @%s: %s", Uninterruptible.class.getSimpleName(), handlerMethods[0]); - JavaType[] handlerParameterTypes = handlerMethods[0].toParameterTypes(); - UserError.guarantee(handlerParameterTypes.length == 1 && - ((ResolvedJavaType) handlerParameterTypes[0]).isAssignableFrom(throwable), + List handlerParameterTypes = handlerMethods[0].toParameterList(); + UserError.guarantee(handlerParameterTypes.size() == 1 && + handlerParameterTypes.get(0).isAssignableFrom(throwable), "Exception handler method must have exactly one parameter of type Throwable: %s -> %s", targetMethod, handlerMethods[0]); InvokeWithExceptionNode handlerInvoke = kit.startInvokeWithException(handlerMethods[0], InvokeKind.Static, kit.getFrameState(), kit.bci(), exception); kit.noExceptionPart(); @@ -545,7 +537,7 @@ private void generateExceptionHandler(HostedProviders providers, HostedGraphKit } /* The exception is handled, we can continue with the normal epilogue. */ - generateEpilogueAndReturn(providers, kit, returnValue); + generateEpilogueAndReturn(kit, returnValue); kit.exceptionPart(); // fail-safe for exceptions in exception handler kit.append(new CEntryPointLeaveNode(LeaveAction.ExceptionAbort, kit.exceptionObject())); @@ -554,20 +546,20 @@ private void generateExceptionHandler(HostedProviders providers, HostedGraphKit } } - private ValueNode adaptReturnValue(HostedProviders providers, HostedGraphKit kit, ValueNode value) { + private ValueNode adaptReturnValue(HostedGraphKit kit, ValueNode value) { ValueNode returnValue = value; if (returnValue.getStackKind().isPrimitive()) { return returnValue; } - JavaType returnType = targetSignature.getReturnType(null); + AnalysisType returnType = targetSignature.getReturnType(); NativeLibraries nativeLibraries = CEntryPointCallStubSupport.singleton().getNativeLibraries(); - ElementInfo typeInfo = nativeLibraries.findElementInfo((ResolvedJavaType) returnType); + ElementInfo typeInfo = nativeLibraries.findElementInfo(returnType); if (typeInfo instanceof EnumInfo) { // Always return enum values as a signed word because it should never be a problem if // the caller expects a narrower integer type and the various checks already handle // replacements with word types. - CInterfaceEnumTool tool = new CInterfaceEnumTool(providers.getMetaAccess(), providers.getSnippetReflection()); - JavaKind cEnumReturnType = providers.getWordTypes().getWordKind(); + CInterfaceEnumTool tool = new CInterfaceEnumTool(kit.getMetaAccess(), kit.getSnippetReflection()); + JavaKind cEnumReturnType = kit.getWordTypes().getWordKind(); assert !cEnumReturnType.isUnsigned() : "requires correct representation of signed values"; returnValue = tool.startEnumValueInvokeWithException(kit, (EnumInfo) typeInfo, cEnumReturnType, returnValue); kit.exceptionPart(); @@ -582,7 +574,7 @@ private ValueNode adaptReturnValue(HostedProviders providers, HostedGraphKit kit return returnValue; } - private void generateEpilogue(HostedProviders providers, SubstrateGraphKit kit) { + private void generateEpilogue(HostedGraphKit kit) { Class epilogueClass = entryPointData.getEpilogue(); if (epilogueClass == NoEpilogue.class) { UserError.guarantee(Uninterruptible.Utils.isUninterruptible(targetMethod), @@ -593,8 +585,8 @@ private void generateEpilogue(HostedProviders providers, SubstrateGraphKit kit) targetMethod); return; } - ResolvedJavaType epilogue = providers.getMetaAccess().lookupJavaType(epilogueClass); - ResolvedJavaMethod[] epilogueMethods = epilogue.getDeclaredMethods(false); + AnalysisType epilogue = kit.getMetaAccess().lookupJavaType(epilogueClass); + AnalysisMethod[] epilogueMethods = epilogue.getDeclaredMethods(false); UserError.guarantee(epilogueMethods.length == 1 && epilogueMethods[0].isStatic() && epilogueMethods[0].getSignature().getParameterCount(false) == 0, "Epilogue class must declare exactly one static method without parameters: %s -> %s", targetMethod, epilogue); UserError.guarantee(Uninterruptible.Utils.isUninterruptible(epilogueMethods[0]), diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CEntryPointJavaCallStubMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CEntryPointJavaCallStubMethod.java index 9e5f4e18ac25..5db0aa2c2a72 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CEntryPointJavaCallStubMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CEntryPointJavaCallStubMethod.java @@ -27,17 +27,16 @@ import java.lang.reflect.AnnotatedElement; import java.util.List; -import jdk.graal.compiler.nodes.ConstantNode; -import jdk.graal.compiler.nodes.ValueNode; -import jdk.graal.compiler.nodes.java.LoadFieldNode; import org.graalvm.nativeimage.c.function.CEntryPoint; import org.graalvm.nativeimage.c.function.CFunctionPointer; -import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.core.c.BoxedRelocatedPointer; import com.oracle.svm.core.thread.VMThreads.StatusSupport; import com.oracle.svm.hosted.phases.HostedGraphKit; +import jdk.graal.compiler.nodes.ConstantNode; +import jdk.graal.compiler.nodes.ValueNode; +import jdk.graal.compiler.nodes.java.LoadFieldNode; import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.ResolvedJavaType; @@ -74,7 +73,7 @@ protected String getCorrespondingAnnotationName() { } @Override - protected ValueNode createTargetAddressNode(HostedGraphKit kit, HostedProviders providers, List arguments) { + protected ValueNode createTargetAddressNode(HostedGraphKit kit, List arguments) { /* * We currently cannot handle {@link MethodPointer} as a constant in the code, so we use an diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CFunctionCallStubMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CFunctionCallStubMethod.java index 59d29d9e537f..d9d26d99996e 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CFunctionCallStubMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CFunctionCallStubMethod.java @@ -27,11 +27,11 @@ import java.util.Arrays; import java.util.List; -import jdk.graal.compiler.debug.DebugContext; -import jdk.graal.compiler.nodes.StructuredGraph; -import jdk.graal.compiler.nodes.ValueNode; import org.graalvm.nativeimage.c.function.CFunction; +import com.oracle.graal.pointsto.infrastructure.ResolvedSignature; +import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.AnalysisType; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.core.graal.code.CGlobalDataInfo; import com.oracle.svm.core.graal.nodes.CGlobalDataLoadAddressNode; @@ -41,9 +41,10 @@ import com.oracle.svm.hosted.phases.HostedGraphKit; import com.oracle.svm.util.ClassUtil; -import jdk.vm.ci.meta.JavaType; +import jdk.graal.compiler.debug.DebugContext; +import jdk.graal.compiler.nodes.StructuredGraph; +import jdk.graal.compiler.nodes.ValueNode; import jdk.vm.ci.meta.ResolvedJavaMethod; -import jdk.vm.ci.meta.Signature; /** * Call stub for invoking C functions via methods annotated with {@link CFunction}. @@ -82,31 +83,26 @@ public boolean allowRuntimeCompilation() { } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { assert purpose != Purpose.PREPARE_RUNTIME_COMPILATION || allowRuntimeCompilation(); return super.buildGraph(debug, method, providers, purpose); } @Override - protected ValueNode createTargetAddressNode(HostedGraphKit kit, HostedProviders providers, List arguments) { + protected ValueNode createTargetAddressNode(HostedGraphKit kit, List arguments) { return kit.unique(new CGlobalDataLoadAddressNode(linkage)); } @Override - protected JavaType[] getParameterTypesForLoad(ResolvedJavaMethod method) { - return method.toParameterTypes(); // include a potential receiver - } - - @Override - protected Signature adaptSignatureAndConvertArguments(HostedProviders providers, NativeLibraries nativeLibraries, - HostedGraphKit kit, ResolvedJavaMethod method, JavaType returnType, JavaType[] paramTypes, List arguments) { - JavaType[] adaptedParamTypes = paramTypes; + protected ResolvedSignature adaptSignatureAndConvertArguments(NativeLibraries nativeLibraries, + HostedGraphKit kit, AnalysisMethod method, AnalysisType returnType, AnalysisType[] paramTypes, List arguments) { + var adaptedParamTypes = paramTypes; if (method.hasReceiver()) { // For non-static methods, we ignore the receiver. arguments.remove(0); adaptedParamTypes = Arrays.copyOfRange(adaptedParamTypes, 1, adaptedParamTypes.length); } - return super.adaptSignatureAndConvertArguments(providers, nativeLibraries, kit, method, returnType, adaptedParamTypes, arguments); + return super.adaptSignatureAndConvertArguments(nativeLibraries, kit, method, returnType, adaptedParamTypes, arguments); } } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CFunctionPointerCallStubMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CFunctionPointerCallStubMethod.java index eb11296acf92..ba2af8a72645 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CFunctionPointerCallStubMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CFunctionPointerCallStubMethod.java @@ -28,17 +28,19 @@ import java.util.Arrays; import java.util.List; -import jdk.graal.compiler.debug.DebugContext; -import jdk.graal.compiler.nodes.StructuredGraph; -import jdk.graal.compiler.nodes.ValueNode; import org.graalvm.nativeimage.c.function.InvokeCFunctionPointer; +import com.oracle.graal.pointsto.infrastructure.ResolvedSignature; import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.AnalysisType; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.core.thread.VMThreads.StatusSupport; import com.oracle.svm.hosted.c.NativeLibraries; import com.oracle.svm.hosted.phases.HostedGraphKit; +import jdk.graal.compiler.debug.DebugContext; +import jdk.graal.compiler.nodes.StructuredGraph; +import jdk.graal.compiler.nodes.ValueNode; import jdk.vm.ci.meta.JavaType; import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.ResolvedJavaType; @@ -127,28 +129,23 @@ public boolean allowRuntimeCompilation() { } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { assert purpose != Purpose.PREPARE_RUNTIME_COMPILATION || allowRuntimeCompilation(); return super.buildGraph(debug, method, providers, purpose); } @Override - protected JavaType[] getParameterTypesForLoad(ResolvedJavaMethod method) { - return method.toParameterTypes(); // include receiver = call target address - } - - @Override - protected ValueNode createTargetAddressNode(HostedGraphKit kit, HostedProviders providers, List arguments) { + protected ValueNode createTargetAddressNode(HostedGraphKit kit, List arguments) { return arguments.get(0); } @Override - protected Signature adaptSignatureAndConvertArguments(HostedProviders providers, NativeLibraries nativeLibraries, - HostedGraphKit kit, ResolvedJavaMethod method, JavaType returnType, JavaType[] paramTypes, List arguments) { + protected ResolvedSignature adaptSignatureAndConvertArguments(NativeLibraries nativeLibraries, + HostedGraphKit kit, AnalysisMethod method, AnalysisType returnType, AnalysisType[] paramTypes, List arguments) { // First argument is the call target address, not an actual argument arguments.remove(0); - JavaType[] paramTypesNoReceiver = Arrays.copyOfRange(paramTypes, 1, paramTypes.length); - return super.adaptSignatureAndConvertArguments(providers, nativeLibraries, kit, method, returnType, paramTypesNoReceiver, arguments); + var paramTypesNoReceiver = Arrays.copyOfRange(paramTypes, 1, paramTypes.length); + return super.adaptSignatureAndConvertArguments(nativeLibraries, kit, method, returnType, paramTypesNoReceiver, arguments); } } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CompileQueue.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CompileQueue.java index dc1f6fa2b35a..3f7628962290 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CompileQueue.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/CompileQueue.java @@ -48,7 +48,6 @@ import com.oracle.graal.pointsto.util.CompletionExecutor.DebugContextRunnable; import com.oracle.svm.common.meta.MultiMethod; import com.oracle.svm.core.SubstrateOptions; -import com.oracle.svm.core.SubstrateOptions.OptimizationLevel; import com.oracle.svm.core.Uninterruptible; import com.oracle.svm.core.config.ConfigurationValues; import com.oracle.svm.core.deopt.DeoptTest; @@ -116,8 +115,6 @@ import jdk.graal.compiler.nodes.StructuredGraph; import jdk.graal.compiler.nodes.ValueNode; import jdk.graal.compiler.nodes.graphbuilderconf.GeneratedFoldInvocationPlugin; -import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration; -import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration.BytecodeExceptionMode; import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderContext; import jdk.graal.compiler.nodes.graphbuilderconf.InlineInvokePlugin; import jdk.graal.compiler.nodes.java.MethodCallTargetNode; @@ -1044,23 +1041,6 @@ protected OptionValues getCustomizedOptions(@SuppressWarnings("unused") HostedMe return debug.getOptions(); } - protected GraphBuilderConfiguration createHostedGraphBuilderConfiguration(HostedProviders providers, HostedMethod method) { - GraphBuilderConfiguration gbConf = GraphBuilderConfiguration.getDefault(providers.getGraphBuilderPlugins()).withBytecodeExceptionMode(BytecodeExceptionMode.CheckAll); - - if (SubstrateOptions.optimizationLevel() == OptimizationLevel.O0 && !method.isDeoptTarget()) { - /* - * Disabling liveness analysis preserves the values of local variables beyond the - * bytecode-liveness. This greatly helps debugging. When local variable numbers are - * reused by javac, local variables can still get illegal values. Since we cannot - * "restore" such illegal values during deoptimization, we cannot disable liveness - * analysis for deoptimization target methods. - */ - gbConf = gbConf.withRetainLocalVariables(true); - } - - return gbConf; - } - protected boolean canBeUsedForInlining(Invoke invoke) { HostedMethod caller = (HostedMethod) invoke.asNode().graph().method(); HostedMethod callee = (HostedMethod) invoke.callTarget().targetMethod(); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/FactoryMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/FactoryMethod.java index 2b6a0695a31c..2ebe820aca98 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/FactoryMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/FactoryMethod.java @@ -26,7 +26,6 @@ import org.graalvm.nativeimage.ImageSingletons; -import com.oracle.graal.pointsto.meta.AnalysisMetaAccess; import com.oracle.graal.pointsto.meta.AnalysisMethod; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.core.NeverInlineTrivial; @@ -81,16 +80,15 @@ public AnnotationValue[] getInjectedAnnotations() { } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { + HostedGraphKit kit = new HostedGraphKit(debug, providers, method); FactoryMethodSupport support = ImageSingletons.lookup(FactoryMethodSupport.class); - AnalysisMetaAccess aMetaAccess = (AnalysisMetaAccess) providers.getMetaAccess(); - AnalysisMethod aTargetConstructor = aMetaAccess.getUniverse().lookup(targetConstructor); - HostedGraphKit kit = new HostedGraphKit(debug, providers, method); + AnalysisMethod aTargetConstructor = kit.getMetaAccess().getUniverse().lookup(targetConstructor); AbstractNewObjectNode newInstance = support.createNewInstance(kit, aTargetConstructor.getDeclaringClass(), true); - ValueNode[] originalArgs = kit.loadArguments(method.toParameterTypes()).toArray(ValueNode.EMPTY_ARRAY); + ValueNode[] originalArgs = kit.getInitialArguments().toArray(ValueNode.EMPTY_ARRAY); ValueNode[] invokeArgs = new ValueNode[originalArgs.length + 1]; invokeArgs[0] = newInstance; System.arraycopy(originalArgs, 0, invokeArgs, 1, originalArgs.length); @@ -107,9 +105,4 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, public ResolvedJavaMethod getTargetConstructor() { return targetConstructor; } - - @Override - public ResolvedJavaType getDeclaringClass() { - return super.getDeclaringClass(); - } } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/FactoryMethodSupport.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/FactoryMethodSupport.java index 64084526336e..e56cc3e54846 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/FactoryMethodSupport.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/FactoryMethodSupport.java @@ -29,9 +29,9 @@ import org.graalvm.nativeimage.ImageSingletons; +import com.oracle.graal.pointsto.infrastructure.ResolvedSignature; import com.oracle.graal.pointsto.meta.AnalysisMetaAccess; import com.oracle.graal.pointsto.meta.AnalysisMethod; -import com.oracle.graal.pointsto.meta.AnalysisType; import com.oracle.svm.core.SubstrateUtil; import com.oracle.svm.core.code.FactoryMethodHolder; import com.oracle.svm.core.code.FactoryThrowMethodHolder; @@ -71,10 +71,10 @@ public AnalysisMethod lookup(AnalysisMetaAccess aMetaAccess, AnalysisMethod aCon */ ResolvedJavaType[] unwrappedParameterTypes = new ResolvedJavaType[aConstructor.getSignature().getParameterCount(false)]; for (int i = 0; i < unwrappedParameterTypes.length; i++) { - unwrappedParameterTypes[i] = ((AnalysisType) aConstructor.getSignature().getParameterType(i, null)).getWrapped(); + unwrappedParameterTypes[i] = aConstructor.getSignature().getParameterType(i).getWrapped(); } ResolvedJavaType unwrappedReturnType = (throwAllocatedObject ? aMetaAccess.lookupJavaType(void.class) : aConstructor.getDeclaringClass()).getWrapped(); - Signature unwrappedSignature = new SimpleSignature(unwrappedParameterTypes, unwrappedReturnType); + Signature unwrappedSignature = ResolvedSignature.fromArray(unwrappedParameterTypes, unwrappedReturnType); ResolvedJavaMethod unwrappedConstructor = aConstructor.getWrapped(); ResolvedJavaType unwrappedDeclaringClass = (aMetaAccess.lookupJavaType(throwAllocatedObject ? FactoryThrowMethodHolder.class : FactoryMethodHolder.class)).getWrapped(); ConstantPool unwrappedConstantPool = unwrappedConstructor.getConstantPool(); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/IncompatibleClassChangeFallbackMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/IncompatibleClassChangeFallbackMethod.java index 05433c56074a..ec74defc72db 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/IncompatibleClassChangeFallbackMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/IncompatibleClassChangeFallbackMethod.java @@ -24,6 +24,7 @@ */ package com.oracle.svm.hosted.code; +import com.oracle.graal.pointsto.meta.AnalysisMethod; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.hosted.analysis.NativeImagePointsToAnalysis; import com.oracle.svm.hosted.phases.HostedGraphKit; @@ -67,9 +68,9 @@ public ResolvedJavaMethod getOriginal() { } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { HostedGraphKit kit = new HostedGraphKit(debug, providers, method); - ResolvedJavaMethod constructor = providers.getMetaAccess().lookupJavaMethod(ReflectionUtil.lookupConstructor(resolutionError)); + AnalysisMethod constructor = kit.getMetaAccess().lookupJavaMethod(ReflectionUtil.lookupConstructor(resolutionError)); AbstractNewObjectNode newInstance = kit.append(new NewInstanceNode(constructor.getDeclaringClass(), true)); kit.createInvokeWithExceptionAndUnwind(constructor, InvokeKind.Special, kit.getFrameState(), kit.bci(), newInstance); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/SimpleSignature.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/SimpleSignature.java deleted file mode 100644 index 17aacf9f159c..000000000000 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/SimpleSignature.java +++ /dev/null @@ -1,124 +0,0 @@ -/* - * Copyright (c) 2017, 2017, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the "Classpath" exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package com.oracle.svm.hosted.code; - -import java.lang.invoke.MethodType; -import java.util.Arrays; -import java.util.List; -import java.util.Objects; -import java.util.stream.Collectors; - -import com.oracle.svm.core.SubstrateUtil; - -import jdk.vm.ci.meta.JavaKind; -import jdk.vm.ci.meta.JavaType; -import jdk.vm.ci.meta.MetaAccessProvider; -import jdk.vm.ci.meta.ResolvedJavaType; -import jdk.vm.ci.meta.Signature; - -/** - * A straightforward implementation of {@link Signature}. - */ -public class SimpleSignature implements Signature { - public static SimpleSignature fromKinds(JavaKind[] paramKinds, JavaKind returnKind, MetaAccessProvider metaAccess) { - ResolvedJavaType[] paramTypes = new ResolvedJavaType[paramKinds.length]; - for (int i = 0; i < paramKinds.length; i++) { - paramTypes[i] = SimpleSignature.resolveType(paramKinds[i], metaAccess); - } - JavaType returnType = SimpleSignature.resolveType(returnKind, metaAccess); - return new SimpleSignature(paramTypes, returnType); - } - - public static SimpleSignature fromMethodType(MethodType mt, MetaAccessProvider metaAccess) { - return new SimpleSignature( - Arrays.stream(mt.parameterArray()).map(metaAccess::lookupJavaType).collect(Collectors.toList()), - metaAccess.lookupJavaType(mt.returnType())); - } - - private static ResolvedJavaType resolveType(JavaKind kind, MetaAccessProvider metaAccess) { - return metaAccess.lookupJavaType(kind.isObject() ? Object.class : kind.toJavaClass()); - } - - private final JavaType[] parameterTypes; - private final JavaType returnType; - - public SimpleSignature(JavaType[] parameterTypes, JavaType returnType) { - this.parameterTypes = parameterTypes; - this.returnType = returnType; - } - - public SimpleSignature(List parameterTypes, JavaType returnType) { - this(parameterTypes.toArray(new JavaType[0]), returnType); - } - - @Override - public int getParameterCount(boolean receiver) { - return parameterTypes.length; - } - - @Override - public JavaType getParameterType(int index, ResolvedJavaType accessingClass) { - return parameterTypes[index]; - } - - @Override - public JavaType getReturnType(ResolvedJavaType accessingClass) { - return returnType; - } - - public String getIdentifier() { - StringBuilder sb = new StringBuilder(1 + parameterTypes.length); - boolean digest = false; - for (JavaType type : parameterTypes) { - if (type.getJavaKind().isPrimitive() || (type instanceof ResolvedJavaType && ((ResolvedJavaType) type).isJavaLangObject())) { - sb.append(type.getJavaKind().getTypeChar()); - } else { - sb.append(type.toClassName()); - digest = true; - } - } - sb.append('_').append(returnType.getJavaKind().getTypeChar()); - return digest ? SubstrateUtil.digest(sb.toString()) : sb.toString(); - } - - @Override - public boolean equals(Object obj) { - if (this != obj && obj instanceof SimpleSignature) { - var other = (SimpleSignature) obj; - return Arrays.equals(parameterTypes, other.parameterTypes) && Objects.equals(returnType, other.returnType); - } - return (this == obj); - } - - @Override - public int hashCode() { - return Arrays.hashCode(parameterTypes) * 31 + Objects.hashCode(returnType); - } - - @Override - public String toString() { - return getIdentifier(); - } -} diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/heap/PodFactorySubstitutionMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/heap/PodFactorySubstitutionMethod.java index 5f8376567a7b..3c68a2fad589 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/heap/PodFactorySubstitutionMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/heap/PodFactorySubstitutionMethod.java @@ -32,6 +32,9 @@ import org.graalvm.nativeimage.AnnotationAccess; import com.oracle.graal.pointsto.infrastructure.SubstitutionProcessor; +import com.oracle.graal.pointsto.meta.AnalysisField; +import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.AnalysisType; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.common.meta.MultiMethod; import com.oracle.svm.core.deopt.DeoptTest; @@ -65,9 +68,7 @@ import jdk.graal.compiler.nodes.ValueNode; import jdk.graal.compiler.nodes.java.ExceptionObjectNode; import jdk.vm.ci.meta.JavaKind; -import jdk.vm.ci.meta.ResolvedJavaField; import jdk.vm.ci.meta.ResolvedJavaMethod; -import jdk.vm.ci.meta.ResolvedJavaType; final class PodFactorySubstitutionProcessor extends SubstitutionProcessor { private final ConcurrentMap substitutions = new ConcurrentHashMap<>(); @@ -119,17 +120,17 @@ public int getModifiers() { } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { HostedGraphKit kit = new HostedGraphKit(debug, providers, method); DeoptInfoProvider deoptInfo = null; if (MultiMethod.isDeoptTarget(method)) { - deoptInfo = new DeoptInfoProvider((MultiMethod) method); + deoptInfo = new DeoptInfoProvider(method); } - ResolvedJavaType factoryType = method.getDeclaringClass(); + AnalysisType factoryType = method.getDeclaringClass(); PodFactory annotation = factoryType.getAnnotation(PodFactory.class); - ResolvedJavaType podConcreteType = kit.getMetaAccess().lookupJavaType(annotation.podClass()); - ResolvedJavaMethod targetCtor = findMatchingConstructor(method, podConcreteType.getSuperclass()); + AnalysisType podConcreteType = kit.getMetaAccess().lookupJavaType(annotation.podClass()); + AnalysisMethod targetCtor = findMatchingConstructor(method, podConcreteType.getSuperclass()); /* * The graph must be safe for runtime compilation and so for compilation as a deoptimization @@ -138,11 +139,11 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, */ int instanceLocal = kit.getFrameState().localsSize() - 1; // reserved when generating class int nextDeoptIndex = startMethod(kit, deoptInfo, 0); - instantiatePod(kit, providers, factoryType, podConcreteType, instanceLocal); + instantiatePod(kit, factoryType, podConcreteType, instanceLocal); if (isAnnotationPresent(DeoptTest.class)) { kit.append(new TestDeoptimizeNode()); } - nextDeoptIndex = invokeConstructor(kit, method, deoptInfo, nextDeoptIndex, targetCtor, instanceLocal); + nextDeoptIndex = invokeConstructor(kit, deoptInfo, nextDeoptIndex, targetCtor, instanceLocal); kit.createReturn(kit.loadLocal(instanceLocal, JavaKind.Object), JavaKind.Object); return kit.finalizeGraph(); @@ -154,8 +155,8 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, * * @throws GraalError if no matching constructor found */ - private ResolvedJavaMethod findMatchingConstructor(ResolvedJavaMethod method, ResolvedJavaType typeToSearch) { - for (ResolvedJavaMethod ctor : typeToSearch.getDeclaredConstructors(false)) { + private AnalysisMethod findMatchingConstructor(AnalysisMethod method, AnalysisType typeToSearch) { + for (AnalysisMethod ctor : typeToSearch.getDeclaredConstructors(false)) { if (parameterTypesMatch(method, ctor)) { return ctor; } @@ -180,31 +181,31 @@ private static int startMethod(HostedGraphKit kit, DeoptInfoProvider deoptInfo, return nextDeoptIndex; } - private static void instantiatePod(HostedGraphKit kit, HostedProviders providers, ResolvedJavaType factoryType, ResolvedJavaType podConcreteType, int instanceLocal) { - ResolvedJavaType podType = kit.getMetaAccess().lookupJavaType(Pod.class); + private static void instantiatePod(HostedGraphKit kit, AnalysisType factoryType, AnalysisType podConcreteType, int instanceLocal) { + AnalysisType podType = kit.getMetaAccess().lookupJavaType(Pod.class); ValueNode receiver = kit.loadLocal(0, JavaKind.Object); ValueNode pod = loadNonNullField(kit, receiver, findField(factoryType, "pod")); ValueNode arrayLength = kit.createLoadField(pod, findField(podType, "arrayLength")); ValueNode refMap = loadNonNullField(kit, pod, findField(podType, "referenceMap")); - ConstantNode hub = kit.createConstant(providers.getConstantReflection().asObjectHub(podConcreteType), JavaKind.Object); + ConstantNode hub = kit.createConstant(kit.getConstantReflection().asObjectHub(podConcreteType), JavaKind.Object); ValueNode instance = kit.append(new NewPodInstanceNode(podConcreteType, hub, arrayLength, refMap)); kit.storeLocal(instanceLocal, JavaKind.Object, instance); } - private static ValueNode loadNonNullField(HostedGraphKit kit, ValueNode object, ResolvedJavaField field) { + private static ValueNode loadNonNullField(HostedGraphKit kit, ValueNode object, AnalysisField field) { return kit.append(PiNode.create(kit.createLoadField(object, field), StampFactory.objectNonNull())); } - private static int invokeConstructor(HostedGraphKit kit, ResolvedJavaMethod method, DeoptInfoProvider deoptInfo, int nextDeoptIndex, ResolvedJavaMethod targetCtor, int instanceLocal) { + private static int invokeConstructor(HostedGraphKit kit, DeoptInfoProvider deoptInfo, int nextDeoptIndex, AnalysisMethod targetCtor, int instanceLocal) { ValueNode instance = kit.loadLocal(instanceLocal, JavaKind.Object); - ValueNode[] originalArgs = kit.loadArguments(method.toParameterTypes()).toArray(ValueNode.EMPTY_ARRAY); + ValueNode[] originalArgs = kit.getInitialArguments().toArray(ValueNode.EMPTY_ARRAY); ValueNode[] invokeArgs = Arrays.copyOf(originalArgs, originalArgs.length); invokeArgs[0] = instance; return invokeWithDeoptAndExceptionUnwind(kit, deoptInfo, nextDeoptIndex, targetCtor, InvokeKind.Special, invokeArgs); } /** @see com.oracle.svm.hosted.phases.SharedGraphBuilderPhase */ - private static int invokeWithDeoptAndExceptionUnwind(HostedGraphKit kit, DeoptInfoProvider deoptInfo, int initialNextDeoptIndex, ResolvedJavaMethod target, InvokeKind invokeKind, + private static int invokeWithDeoptAndExceptionUnwind(HostedGraphKit kit, DeoptInfoProvider deoptInfo, int initialNextDeoptIndex, AnalysisMethod target, InvokeKind invokeKind, ValueNode... args) { int bci = kit.bci(); InvokeWithExceptionNode invoke = kit.startInvokeWithException(target, invokeKind, kit.getFrameState(), bci, args); @@ -293,22 +294,22 @@ private static ValueNode createDeoptProxy(HostedGraphKit kit, int nextDeoptIndex return kit.getGraph().addOrUniqueWithInputs(DeoptProxyNode.create(value, deoptTarget, nextDeoptIndex)); } - private static boolean parameterTypesMatch(ResolvedJavaMethod method, ResolvedJavaMethod ctor) { + private static boolean parameterTypesMatch(AnalysisMethod method, AnalysisMethod ctor) { int paramsCount = method.getSignature().getParameterCount(false); if (paramsCount != ctor.getSignature().getParameterCount(false)) { return false; } for (int i = 0; i < paramsCount; i++) { - if (!ctor.getSignature().getParameterType(i, ctor.getDeclaringClass()) - .equals(method.getSignature().getParameterType(i, method.getDeclaringClass()))) { + if (!ctor.getSignature().getParameterType(i).equals(method.getSignature().getParameterType(i))) { return false; } } return true; } - private static ResolvedJavaField findField(ResolvedJavaType type, String name) { - for (ResolvedJavaField field : type.getInstanceFields(false)) { + private static AnalysisField findField(AnalysisType type, String name) { + for (var f : type.getInstanceFields(false)) { + AnalysisField field = (AnalysisField) f; if (field.getName().equals(name)) { return field; } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImage.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImage.java index dd949466ad9e..db3d31bca211 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImage.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImage.java @@ -105,6 +105,7 @@ import com.oracle.svm.hosted.image.RelocatableBuffer.Info; import com.oracle.svm.hosted.meta.HostedMetaAccess; import com.oracle.svm.hosted.meta.HostedMethod; +import com.oracle.svm.hosted.meta.HostedType; import com.oracle.svm.hosted.meta.HostedUniverse; import com.oracle.svm.util.ReflectionUtil; import com.oracle.svm.util.ReflectionUtil.ReflectionUtilError; @@ -123,7 +124,6 @@ import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.ResolvedJavaMethod.Parameter; -import jdk.vm.ci.meta.ResolvedJavaType; public abstract class NativeImage extends AbstractImage { public static final long RWDATA_CGLOBALS_PARTITION_OFFSET = 0; @@ -323,7 +323,7 @@ private void writeMethodHeader(HostedMethod m, CSourceCodeWriter writer, boolean AnnotatedType annotatedReturnType = getAnnotatedReturnType(m); writer.append(CSourceCodeWriter.toCTypeName(m, - (ResolvedJavaType) m.getSignature().getReturnType(m.getDeclaringClass()), + m.getSignature().getReturnType(), Optional.ofNullable(annotatedReturnType.getAnnotation(CTypedef.class)).map(CTypedef::name), false, isUnsigned(annotatedReturnType), @@ -347,7 +347,7 @@ private void writeMethodHeader(HostedMethod m, CSourceCodeWriter writer, boolean writer.append(sep); sep = ", "; writer.append(CSourceCodeWriter.toCTypeName(m, - (ResolvedJavaType) m.getSignature().getParameterType(i, m.getDeclaringClass()), + m.getSignature().getParameterType(i), Optional.ofNullable(annotatedParameterTypes[i].getAnnotation(CTypedef.class)).map(CTypedef::name), annotatedParameterTypes[i].isAnnotationPresent(CConst.class), isUnsigned(annotatedParameterTypes[i]), @@ -919,8 +919,8 @@ protected void writeTextSection(DebugContext debug, final Section textSection, f * We've hit a signature with multiple methods. Choose the "more specific" * of the two methods, i.e. the overriding covariant signature. */ - final ResolvedJavaType existingReturnType = existing.getSignature().getReturnType(null).resolve(existing.getDeclaringClass()); - final ResolvedJavaType currentReturnType = current.getSignature().getReturnType(null).resolve(current.getDeclaringClass()); + HostedType existingReturnType = existing.getSignature().getReturnType(); + HostedType currentReturnType = current.getSignature().getReturnType(); if (existingReturnType.isAssignableFrom(currentReturnType)) { /* current is more specific than existing */ final HostedMethod replaced = methodsBySignature.put(signatureString, current); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImageCodeCache.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImageCodeCache.java index a0f94651c576..73575d220ac7 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImageCodeCache.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImageCodeCache.java @@ -117,7 +117,6 @@ import jdk.vm.ci.meta.Constant; import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.JavaKind; -import jdk.vm.ci.meta.JavaType; import jdk.vm.ci.meta.MetaAccessProvider; import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.VMConstant; @@ -382,13 +381,11 @@ protected void buildRuntimeMetadata(DebugContext debug, SnippetReflectionProvide if (includedMethods.add(analysisMethod)) { HostedType declaringType = hUniverse.lookup(analysisMethod.getDeclaringClass()); String name = analysisMethod.getName(); - JavaType[] analysisParameterTypes = analysisMethod.getSignature().toParameterTypes(null); - HostedType[] parameterTypes = new HostedType[analysisParameterTypes.length]; - for (int i = 0; i < analysisParameterTypes.length; ++i) { - parameterTypes[i] = hUniverse.lookup(analysisParameterTypes[i]); - } + HostedType[] parameterTypes = analysisMethod.getSignature().toParameterList(null).stream() + .map(aType -> hUniverse.lookup(aType)) + .toArray(HostedType[]::new); int modifiers = analysisMethod.getModifiers(); - HostedType returnType = hUniverse.lookup(analysisMethod.getSignature().getReturnType(null)); + HostedType returnType = hUniverse.lookup(analysisMethod.getSignature().getReturnType()); reflectionMetadataEncoder.addHidingMethodMetadata(analysisMethod, declaringType, name, parameterTypes, modifiers, returnType); } } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImageDebugInfoProviderBase.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImageDebugInfoProviderBase.java index 46d60ffd40c2..87ca9b83eabe 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImageDebugInfoProviderBase.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImageDebugInfoProviderBase.java @@ -25,10 +25,17 @@ */ package com.oracle.svm.hosted.image; +import static com.oracle.svm.hosted.c.info.AccessorInfo.AccessorKind.ADDRESS; +import static com.oracle.svm.hosted.c.info.AccessorInfo.AccessorKind.GETTER; +import static com.oracle.svm.hosted.c.info.AccessorInfo.AccessorKind.SETTER; + import java.nio.file.FileSystems; import java.nio.file.Path; import java.util.HashMap; +import org.graalvm.nativeimage.ImageSingletons; +import org.graalvm.word.WordBase; + import com.oracle.svm.core.StaticFieldsSupport; import com.oracle.svm.core.SubstrateOptions; import com.oracle.svm.core.config.ConfigurationValues; @@ -55,6 +62,7 @@ import com.oracle.svm.hosted.substitute.InjectedFieldsType; import com.oracle.svm.hosted.substitute.SubstitutionMethod; import com.oracle.svm.hosted.substitute.SubstitutionType; + import jdk.graal.compiler.core.common.CompressEncoding; import jdk.graal.compiler.core.target.Backend; import jdk.vm.ci.code.RegisterConfig; @@ -63,14 +71,6 @@ import jdk.vm.ci.meta.JavaType; import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.ResolvedJavaType; -import jdk.vm.ci.meta.Signature; - -import org.graalvm.nativeimage.ImageSingletons; -import org.graalvm.word.WordBase; - -import static com.oracle.svm.hosted.c.info.AccessorInfo.AccessorKind.ADDRESS; -import static com.oracle.svm.hosted.c.info.AccessorInfo.AccessorKind.GETTER; -import static com.oracle.svm.hosted.c.info.AccessorInfo.AccessorKind.SETTER; /** * Abstract base class for implementation of DebugInfoProvider API providing a suite of useful @@ -448,12 +448,12 @@ protected SubstrateCallingConvention getCallingConvention(HostedMethod method) { SubstrateCallingConventionKind callingConventionKind = method.getCallingConventionKind(); HostedType declaringClass = method.getDeclaringClass(); HostedType receiverType = method.isStatic() ? null : declaringClass; - Signature signature = method.getSignature(); + var signature = method.getSignature(); SubstrateCallingConventionType type = callingConventionKind.toType(false); Backend backend = runtimeConfiguration.lookupBackend(method); RegisterConfig registerConfig = backend.getCodeCache().getRegisterConfig(); assert registerConfig instanceof SubstrateRegisterConfig; - return (SubstrateCallingConvention) registerConfig.getCallingConvention(type, signature.getReturnType(null), signature.toParameterTypes(receiverType), backend); + return (SubstrateCallingConvention) registerConfig.getCallingConvention(type, signature.getReturnType(), signature.toParameterTypes(receiverType), backend); } /* diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIAccessFeature.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIAccessFeature.java index 285dd7e7462f..b09b2e537aa3 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIAccessFeature.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIAccessFeature.java @@ -52,6 +52,7 @@ import org.graalvm.word.WordFactory; import com.oracle.graal.pointsto.BigBang; +import com.oracle.graal.pointsto.infrastructure.ResolvedSignature; import com.oracle.graal.pointsto.infrastructure.WrappedJavaType; import com.oracle.graal.pointsto.meta.AnalysisField; import com.oracle.graal.pointsto.meta.AnalysisMethod; @@ -83,7 +84,6 @@ import com.oracle.svm.hosted.ProgressReporter; import com.oracle.svm.hosted.code.CEntryPointData; import com.oracle.svm.hosted.code.FactoryMethodSupport; -import com.oracle.svm.hosted.code.SimpleSignature; import com.oracle.svm.hosted.config.ConfigurationParserUtils; import com.oracle.svm.hosted.config.HybridLayout; import com.oracle.svm.hosted.meta.HostedField; @@ -154,9 +154,9 @@ static final class JNICallableJavaMethod { private boolean sealed = false; private final Map trampolineMethods = new ConcurrentHashMap<>(); - private final Map javaCallWrapperMethods = new ConcurrentHashMap<>(); - private final Map callVariantWrappers = new ConcurrentHashMap<>(); - private final Map nonvirtualCallVariantWrappers = new ConcurrentHashMap<>(); + private final Map, JNIJavaCallWrapperMethod> javaCallWrapperMethods = new ConcurrentHashMap<>(); + private final Map, JNIJavaCallVariantWrapperGroup> callVariantWrappers = new ConcurrentHashMap<>(); + private final Map, JNIJavaCallVariantWrapperGroup> nonvirtualCallVariantWrappers = new ConcurrentHashMap<>(); private final List calledJavaMethods = new ArrayList<>(); private int loadedConfigurations; @@ -378,7 +378,7 @@ private void addMethod(Executable method, DuringAnalysisAccessImpl access) { newObjectMethod = aFactoryMethod.getWrapped(); } - SimpleSignature compatibleSignature = JNIJavaCallWrapperMethod.getGeneralizedSignatureForTarget(targetMethod, originalMetaAccess); + var compatibleSignature = JNIJavaCallWrapperMethod.getGeneralizedSignatureForTarget(targetMethod, originalMetaAccess); JNIJavaCallWrapperMethod callWrapperMethod = javaCallWrapperMethods.computeIfAbsent(compatibleSignature, signature -> factory.create(signature, originalMetaAccess, access.getBigBang().getWordTypes())); access.registerAsRoot(universe.lookup(callWrapperMethod), true, "JNI call wrapper, registered in " + JNIAccessFeature.class); @@ -394,7 +394,7 @@ private void addMethod(Executable method, DuringAnalysisAccessImpl access) { }); } - private JNIJavaCallVariantWrapperGroup createJavaCallVariantWrappers(DuringAnalysisAccessImpl access, SimpleSignature wrapperSignature, boolean nonVirtual) { + private JNIJavaCallVariantWrapperGroup createJavaCallVariantWrappers(DuringAnalysisAccessImpl access, ResolvedSignature wrapperSignature, boolean nonVirtual) { var map = nonVirtual ? nonvirtualCallVariantWrappers : callVariantWrappers; return map.computeIfAbsent(wrapperSignature, signature -> { MetaAccessProvider originalMetaAccess = access.getUniverse().getOriginalMetaAccess(); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNICallTrampolineMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNICallTrampolineMethod.java index 6570f6022478..73a3aabe985f 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNICallTrampolineMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNICallTrampolineMethod.java @@ -30,6 +30,7 @@ import org.graalvm.nativeimage.ImageSingletons; +import com.oracle.graal.pointsto.meta.AnalysisMethod; import com.oracle.graal.pointsto.meta.AnalysisUniverse; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.core.SubstrateOptions; @@ -90,7 +91,7 @@ public int getModifiers() { } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { HostedGraphKit kit = new JNIGraphKit(debug, providers, method); kit.append(new LoweredDeadEndNode()); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIFieldAccessorMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIFieldAccessorMethod.java index c85051b33080..9543c42e7490 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIFieldAccessorMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIFieldAccessorMethod.java @@ -32,6 +32,8 @@ import org.graalvm.nativeimage.c.function.CEntryPoint.Publish; import org.graalvm.word.LocationIdentity; +import com.oracle.graal.pointsto.infrastructure.ResolvedSignature; +import com.oracle.graal.pointsto.meta.AnalysisMethod; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.core.c.function.CEntryPointOptions.AutomaticPrologueBailout; import com.oracle.svm.core.c.function.CEntryPointOptions.NoEpilogue; @@ -45,7 +47,6 @@ import com.oracle.svm.core.util.VMError; import com.oracle.svm.hosted.code.CEntryPointData; import com.oracle.svm.hosted.code.EntryPointCallStubMethod; -import com.oracle.svm.hosted.code.SimpleSignature; import jdk.graal.compiler.debug.DebugContext; import jdk.graal.compiler.java.FrameStateBuilder; @@ -55,9 +56,7 @@ import jdk.graal.compiler.nodes.extended.RawStoreNode; import jdk.vm.ci.meta.ConstantPool; import jdk.vm.ci.meta.JavaKind; -import jdk.vm.ci.meta.JavaType; import jdk.vm.ci.meta.MetaAccessProvider; -import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.ResolvedJavaType; /** @@ -149,13 +148,13 @@ private static String createName(JavaKind fieldKind, boolean isSetter, boolean i return sb.toString(); } - private static SimpleSignature createSignature(JavaKind fieldKind, boolean isSetter, MetaAccessProvider metaAccess) { + private static ResolvedSignature createSignature(JavaKind fieldKind, boolean isSetter, MetaAccessProvider metaAccess) { Class valueClass = fieldKind.toJavaClass(); if (fieldKind.isObject()) { valueClass = JNIObjectHandle.class; } ResolvedJavaType objectHandle = metaAccess.lookupJavaType(JNIObjectHandle.class); - List args = new ArrayList<>(); + List args = new ArrayList<>(); args.add(metaAccess.lookupJavaType(JNIEnvironment.class)); args.add(objectHandle); // this (instance field) or class (static field) args.add(metaAccess.lookupJavaType(JNIFieldId.class)); @@ -168,23 +167,19 @@ private static SimpleSignature createSignature(JavaKind fieldKind, boolean isSet } else { returnType = metaAccess.lookupJavaType(valueClass); } - return new SimpleSignature(args, returnType); + return ResolvedSignature.fromList(args, returnType); } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { JNIGraphKit kit = new JNIGraphKit(debug, providers, method); - StructuredGraph graph = kit.getGraph(); - FrameStateBuilder state = new FrameStateBuilder(null, method, graph); - state.initializeForMethodStart(null, true, providers.getGraphBuilderPlugins()); ValueNode vmThread = kit.loadLocal(0, getSignature().getParameterKind(0)); kit.append(CEntryPointEnterNode.enter(vmThread)); - List arguments = kit.loadArguments(getSignature().toParameterTypes(null)); - ValueNode returnValue = buildGraphBody(kit, arguments, state, providers.getMetaAccess()); + ValueNode returnValue = buildGraphBody(kit, kit.getInitialArguments(), kit.getFrameState(), kit.getMetaAccess()); - kit.appendStateSplitProxy(state); + kit.appendStateSplitProxy(); CEntryPointLeaveNode leave = new CEntryPointLeaveNode(LeaveAction.Leave); kit.append(leave); JavaKind returnKind = isSetter ? JavaKind.Void : fieldKind; diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIGraphKit.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIGraphKit.java index 75a98c8d4a19..e16e55261242 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIGraphKit.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIGraphKit.java @@ -24,7 +24,9 @@ */ package com.oracle.svm.hosted.jni; +import com.oracle.graal.pointsto.infrastructure.ResolvedSignature; import com.oracle.graal.pointsto.meta.HostedProviders; +import com.oracle.svm.core.SubstrateUtil; import com.oracle.svm.core.jni.JNIGeneratedMethodSupport; import com.oracle.svm.core.jni.access.JNIAccessibleMethod; import com.oracle.svm.core.jni.access.JNIReflectionDictionary; @@ -66,6 +68,21 @@ public class JNIGraphKit extends HostedGraphKit { super(debug, providers, method); } + public static String signatureToIdentifier(ResolvedSignature signature) { + StringBuilder sb = new StringBuilder(); + boolean digest = false; + for (var type : signature.toParameterList(null)) { + if (type.getJavaKind().isPrimitive() || type.isJavaLangObject()) { + sb.append(type.getJavaKind().getTypeChar()); + } else { + sb.append(type.toClassName()); + digest = true; + } + } + sb.append('_').append(signature.getReturnType().getJavaKind().getTypeChar()); + return digest ? SubstrateUtil.digest(sb.toString()) : sb.toString(); + } + public ValueNode checkObjectType(ValueNode uncheckedValue, ResolvedJavaType type, boolean checkNonNull) { ValueNode value = uncheckedValue; if (checkNonNull) { diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIJavaCallVariantWrapperMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIJavaCallVariantWrapperMethod.java index 1cf25dd9970e..98b62c38ae82 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIJavaCallVariantWrapperMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIJavaCallVariantWrapperMethod.java @@ -30,7 +30,9 @@ import org.graalvm.nativeimage.Platform; import org.graalvm.word.LocationIdentity; -import com.oracle.graal.pointsto.meta.AnalysisMetaAccess; +import com.oracle.graal.pointsto.infrastructure.ResolvedSignature; +import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.AnalysisType; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.core.graal.code.SubstrateCallingConventionKind; import com.oracle.svm.core.graal.nodes.CEntryPointEnterNode; @@ -43,7 +45,6 @@ import com.oracle.svm.core.jni.JNIJavaCallVariantWrapperHolder; import com.oracle.svm.core.util.VMError; import com.oracle.svm.hosted.code.EntryPointCallStubMethod; -import com.oracle.svm.hosted.code.SimpleSignature; import jdk.graal.compiler.core.common.calc.FloatConvert; import jdk.graal.compiler.core.common.memory.BarrierType; @@ -70,7 +71,7 @@ import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.JavaKind; import jdk.vm.ci.meta.MetaAccessProvider; -import jdk.vm.ci.meta.ResolvedJavaMethod; +import jdk.vm.ci.meta.ResolvedJavaType; import jdk.vm.ci.meta.Signature; /** @@ -84,7 +85,8 @@ public class JNIJavaCallVariantWrapperMethod extends EntryPointCallStubMethod { private final CallVariant callVariant; private final boolean nonVirtual; - public JNIJavaCallVariantWrapperMethod(SimpleSignature callWrapperSignature, CallVariant callVariant, boolean nonVirtual, MetaAccessProvider originalMetaAccess, WordTypes wordTypes) { + public JNIJavaCallVariantWrapperMethod(ResolvedSignature callWrapperSignature, CallVariant callVariant, boolean nonVirtual, MetaAccessProvider originalMetaAccess, + WordTypes wordTypes) { super(createName(callWrapperSignature, callVariant, nonVirtual), originalMetaAccess.lookupJavaType(JNIJavaCallVariantWrapperHolder.class), createSignature(callWrapperSignature, callVariant, nonVirtual, originalMetaAccess, wordTypes), @@ -94,8 +96,8 @@ public JNIJavaCallVariantWrapperMethod(SimpleSignature callWrapperSignature, Cal this.nonVirtual = nonVirtual; } - private static String createName(SimpleSignature targetSignature, CallVariant callVariant, boolean nonVirtual) { - return "invoke" + targetSignature.getIdentifier() + "_" + callVariant.name() + (nonVirtual ? "_Nonvirtual" : ""); + private static String createName(ResolvedSignature targetSignature, CallVariant callVariant, boolean nonVirtual) { + return "invoke" + JNIGraphKit.signatureToIdentifier(targetSignature) + "_" + callVariant.name() + (nonVirtual ? "_Nonvirtual" : ""); } private static Signature createSignature(Signature callWrapperSignature, CallVariant callVariant, boolean nonVirtual, MetaAccessProvider originalMetaAccess, WordTypes wordTypes) { @@ -133,17 +135,16 @@ private static Signature createSignature(Signature callWrapperSignature, CallVar if (returnType.isObject()) { returnType = wordKind; // handle } - return SimpleSignature.fromKinds(args.toArray(JavaKind[]::new), returnType, originalMetaAccess); + return ResolvedSignature.fromKinds(args.toArray(JavaKind[]::new), returnType, originalMetaAccess); } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { - AnalysisMetaAccess aMetaAccess = (AnalysisMetaAccess) providers.getMetaAccess(); + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { JNIGraphKit kit = new JNIGraphKit(debug, providers, method); - Signature invokeSignature = aMetaAccess.getUniverse().lookup(callWrapperSignature, getDeclaringClass()); + var invokeSignature = kit.getMetaAccess().getUniverse().lookup(callWrapperSignature, getDeclaringClass()); - JavaKind wordKind = providers.getWordTypes().getWordKind(); + JavaKind wordKind = kit.getWordTypes().getWordKind(); int slotIndex = 0; ValueNode env = kit.loadLocal(slotIndex, wordKind); slotIndex += wordKind.getSlotCount(); @@ -162,11 +163,11 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, args.add(receiverOrClassHandle); args.add(methodId); args.add(kit.createInt(nonVirtual ? 1 : 0)); - args.addAll(loadArguments(kit, providers, invokeSignature, args.size(), slotIndex)); + args.addAll(loadArguments(kit, invokeSignature, args.size(), slotIndex)); ValueNode formerPendingException = kit.getAndClearPendingException(); - StampPair returnStamp = StampFactory.forDeclaredType(kit.getAssumptions(), invokeSignature.getReturnType(null), false); + StampPair returnStamp = StampFactory.forDeclaredType(kit.getAssumptions(), invokeSignature.getReturnType(), false); CallTargetNode callTarget = new IndirectCallTargetNode(callAddress, args.toArray(ValueNode[]::new), returnStamp, invokeSignature.toParameterTypes(null), null, SubstrateCallingConventionKind.Java.toType(true), InvokeKind.Static); @@ -205,8 +206,8 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, * * @return List of created argument nodes and their type */ - private List loadArguments(JNIGraphKit kit, HostedProviders providers, Signature invokeSignature, int firstParamIndex, int firstSlotIndex) { - JavaKind wordKind = providers.getWordTypes().getWordKind(); + private List loadArguments(JNIGraphKit kit, ResolvedSignature invokeSignature, int firstParamIndex, int firstSlotIndex) { + JavaKind wordKind = kit.getWordTypes().getWordKind(); List args = new ArrayList<>(); int slotIndex = firstSlotIndex; int count = invokeSignature.getParameterCount(false); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIJavaCallWrapperMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIJavaCallWrapperMethod.java index 59b7d3104064..b1a31fbc63bc 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIJavaCallWrapperMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIJavaCallWrapperMethod.java @@ -27,7 +27,9 @@ import java.lang.reflect.Constructor; import java.util.List; -import com.oracle.graal.pointsto.meta.AnalysisMetaAccess; +import com.oracle.graal.pointsto.infrastructure.ResolvedSignature; +import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.AnalysisType; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.core.graal.code.SubstrateCallingConventionKind; import com.oracle.svm.core.graal.nodes.LoweredDeadEndNode; @@ -35,7 +37,6 @@ import com.oracle.svm.core.jni.access.JNIAccessibleMethod; import com.oracle.svm.hosted.code.FactoryMethodSupport; import com.oracle.svm.hosted.code.NonBytecodeMethod; -import com.oracle.svm.hosted.code.SimpleSignature; import com.oracle.svm.util.ReflectionUtil; import jdk.graal.compiler.core.common.type.Stamp; @@ -82,7 +83,7 @@ public class JNIJavaCallWrapperMethod extends NonBytecodeMethod { private static final Constructor INSTANTIATION_EXCEPTION_CONSTRUCTOR = ReflectionUtil.lookupConstructor(InstantiationException.class); public static class Factory { - public JNIJavaCallWrapperMethod create(SimpleSignature targetSignature, MetaAccessProvider originalMetaAccess, WordTypes wordTypes) { + public JNIJavaCallWrapperMethod create(ResolvedSignature targetSignature, MetaAccessProvider originalMetaAccess, WordTypes wordTypes) { return new JNIJavaCallWrapperMethod(targetSignature, originalMetaAccess, wordTypes); } @@ -92,15 +93,10 @@ public boolean canInvokeConstructorOnObject(ResolvedJavaMethod constructor, Meta } } - public static SimpleSignature getGeneralizedSignatureForTarget(ResolvedJavaMethod targetMethod, MetaAccessProvider originalMetaAccess) { - ResolvedJavaType objectType = originalMetaAccess.lookupJavaType(Object.class); - JavaType[] paramTypes = targetMethod.getSignature().toParameterTypes(null); - // Note: does not include the receiver. - for (int i = 0; i < paramTypes.length; i++) { - if (paramTypes[i].getJavaKind().isObject()) { - paramTypes[i] = objectType; - } - } + public static ResolvedSignature getGeneralizedSignatureForTarget(ResolvedJavaMethod targetMethod, MetaAccessProvider originalMetaAccess) { + /* Note: does not include the receiver. */ + JavaKind[] paramKinds = targetMethod.getSignature().toParameterKinds(false); + JavaKind returnKind = targetMethod.getSignature().getReturnKind(); if (targetMethod.isConstructor()) { returnKind = JavaKind.Object; // return new (or previously allocated) object @@ -109,19 +105,19 @@ public static SimpleSignature getGeneralizedSignatureForTarget(ResolvedJavaMetho // wrappers. This is fine with our supported 64-bit calling conventions. returnKind = JavaKind.Long; } - JavaType returnType = returnKind.isObject() ? objectType : originalMetaAccess.lookupJavaType(returnKind.toJavaClass()); - return new SimpleSignature(paramTypes, returnType); + + return ResolvedSignature.fromKinds(paramKinds, returnKind, originalMetaAccess); } private final Signature targetSignature; - protected JNIJavaCallWrapperMethod(SimpleSignature targetSignature, MetaAccessProvider metaAccess, WordTypes wordTypes) { - super("invoke_" + targetSignature.getIdentifier(), true, metaAccess.lookupJavaType(JNIJavaCallWrapperHolder.class), + protected JNIJavaCallWrapperMethod(ResolvedSignature targetSignature, MetaAccessProvider metaAccess, WordTypes wordTypes) { + super("invoke_" + JNIGraphKit.signatureToIdentifier(targetSignature), true, metaAccess.lookupJavaType(JNIJavaCallWrapperHolder.class), createSignature(targetSignature, metaAccess, wordTypes), JNIJavaCallWrapperHolder.getConstantPool(metaAccess)); this.targetSignature = targetSignature; } - private static SimpleSignature createSignature(Signature targetSignature, MetaAccessProvider originalMetaAccess, WordTypes wordTypes) { + private static ResolvedSignature createSignature(Signature targetSignature, MetaAccessProvider originalMetaAccess, WordTypes wordTypes) { JavaKind wordKind = wordTypes.getWordKind(); int count = targetSignature.getParameterCount(false); JavaKind[] args = new JavaKind[3 + count]; @@ -147,22 +143,22 @@ private static SimpleSignature createSignature(Signature targetSignature, MetaAc if (returnKind.isObject()) { returnKind = wordKind; // handle } - return SimpleSignature.fromKinds(args, returnKind, originalMetaAccess); + return ResolvedSignature.fromKinds(args, returnKind, originalMetaAccess); } @Override - public SimpleSignature getSignature() { - return (SimpleSignature) super.getSignature(); + @SuppressWarnings("unchecked") + public ResolvedSignature getSignature() { + return (ResolvedSignature) super.getSignature(); } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { - AnalysisMetaAccess aMetaAccess = (AnalysisMetaAccess) providers.getMetaAccess(); + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { JNIGraphKit kit = new JNIGraphKit(debug, providers, method); - Signature invokeSignature = aMetaAccess.getUniverse().lookup(targetSignature, getDeclaringClass()); + var invokeSignature = kit.getMetaAccess().getUniverse().lookup(targetSignature, getDeclaringClass()); - JavaKind wordKind = providers.getWordTypes().getWordKind(); + JavaKind wordKind = kit.getWordTypes().getWordKind(); int slotIndex = 0; ValueNode receiverOrClassHandle = kit.loadLocal(slotIndex, wordKind); ValueNode receiverOrClass = kit.unboxHandle(receiverOrClassHandle); @@ -172,7 +168,7 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, ValueNode nonVirtual = kit.loadLocal(slotIndex, JavaKind.Boolean.getStackKind()); slotIndex += JavaKind.Boolean.getStackKind().getSlotCount(); - ValueNode[] args = loadAndUnboxArguments(kit, providers, invokeSignature, slotIndex); + ValueNode[] args = loadAndUnboxArguments(kit, invokeSignature, slotIndex); ValueNode returnValue = createCall(kit, invokeSignature, methodId, receiverOrClass, nonVirtual, args); JavaKind returnKind = returnValue.getStackKind(); @@ -183,7 +179,7 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, return kit.finalizeGraph(); } - private ValueNode createCall(JNIGraphKit kit, Signature invokeSignature, ValueNode methodId, ValueNode receiverOrClass, ValueNode nonVirtual, ValueNode[] args) { + private ValueNode createCall(JNIGraphKit kit, ResolvedSignature invokeSignature, ValueNode methodId, ValueNode receiverOrClass, ValueNode nonVirtual, ValueNode[] args) { ValueNode declaringClass = kit.getDeclaringClassForMethod(methodId); if (!invokeSignature.getReturnKind().isObject()) { return createRegularMethodCall(kit, invokeSignature, methodId, receiverOrClass, nonVirtual, args); @@ -199,7 +195,7 @@ private ValueNode createCall(JNIGraphKit kit, Signature invokeSignature, ValueNo return mergeValues(kit, merge, kit.bci(), methodReturnValue, receiverOrCreatedObject); } - private static ValueNode createRegularMethodCall(JNIGraphKit kit, Signature invokeSignature, ValueNode methodId, + private static ValueNode createRegularMethodCall(JNIGraphKit kit, ResolvedSignature invokeSignature, ValueNode methodId, ValueNode receiverOrClass, ValueNode nonVirtual, ValueNode[] args) { ValueNode methodAddress = kit.getJavaCallAddress(methodId, receiverOrClass, nonVirtual); ValueNode isStatic = kit.isStaticMethod(methodId); @@ -207,12 +203,12 @@ private static ValueNode createRegularMethodCall(JNIGraphKit kit, Signature invo kit.thenPart(); ValueNode nonstaticResult = createMethodCallWithReceiver(kit, invokeSignature, methodAddress, receiverOrClass, args); kit.elsePart(); - ValueNode staticResult = createMethodCall(kit, invokeSignature.getReturnType(null), invokeSignature.toParameterTypes(null), methodAddress, args); + ValueNode staticResult = createMethodCall(kit, invokeSignature.getReturnType(), invokeSignature.toParameterTypes(null), methodAddress, args); AbstractMergeNode merge = kit.endIf(); return mergeValues(kit, merge, kit.bci(), nonstaticResult, staticResult); } - protected ValueNode createNewObjectOrConstructorCall(JNIGraphKit kit, Signature invokeSignature, ValueNode methodId, + protected ValueNode createNewObjectOrConstructorCall(JNIGraphKit kit, ResolvedSignature invokeSignature, ValueNode methodId, ValueNode declaringClass, ValueNode newObjectAddress, ValueNode receiverOrClass, ValueNode[] args) { /* * The called function could either be NewObject or CallMethod with a constructor @@ -234,21 +230,21 @@ protected ValueNode createNewObjectOrConstructorCall(JNIGraphKit kit, Signature return mergeValues(kit, merge, kit.bci(), createdObject, receiverOrClass); } - protected ValueNode createConstructorCall(JNIGraphKit kit, Signature invokeSignature, ValueNode methodId, + protected ValueNode createConstructorCall(JNIGraphKit kit, ResolvedSignature invokeSignature, ValueNode methodId, @SuppressWarnings("unused") ValueNode declaringClass, ValueNode receiverOrClass, ValueNode[] args) { ValueNode methodAddress = kit.getJavaCallAddress(methodId, receiverOrClass, kit.createInt(1)); return createMethodCallWithReceiver(kit, invokeSignature, methodAddress, receiverOrClass, args); } - private static ValueNode createMethodCallWithReceiver(JNIGraphKit kit, Signature invokeSignature, ValueNode methodAddress, ValueNode receiver, ValueNode[] args) { + private static ValueNode createMethodCallWithReceiver(JNIGraphKit kit, ResolvedSignature invokeSignature, ValueNode methodAddress, ValueNode receiver, ValueNode[] args) { ValueNode[] argsWithReceiver = new ValueNode[1 + args.length]; argsWithReceiver[0] = kit.maybeCreateExplicitNullCheck(receiver); System.arraycopy(args, 0, argsWithReceiver, 1, args.length); JavaType[] paramTypes = invokeSignature.toParameterTypes(kit.getMetaAccess().lookupJavaType(Object.class)); - return createMethodCall(kit, invokeSignature.getReturnType(null), paramTypes, methodAddress, argsWithReceiver); + return createMethodCall(kit, invokeSignature.getReturnType(), paramTypes, methodAddress, argsWithReceiver); } - private static ValueNode createNewObjectCall(JNIGraphKit kit, Signature invokeSignature, ValueNode newObjectAddress, ValueNode[] args) { + private static ValueNode createNewObjectCall(JNIGraphKit kit, ResolvedSignature invokeSignature, ValueNode newObjectAddress, ValueNode[] args) { ConstantNode abstractTypeSentinel = kit.createWord(JNIAccessibleMethod.NEW_OBJECT_INVALID_FOR_ABSTRACT_TYPE); kit.startIf(IntegerEqualsNode.create(newObjectAddress, abstractTypeSentinel, NodeView.DEFAULT), BranchProbabilityNode.SLOW_PATH_PROFILE); kit.thenPart(); @@ -258,7 +254,7 @@ private static ValueNode createNewObjectCall(JNIGraphKit kit, Signature invokeSi kit.append(new LoweredDeadEndNode()); kit.endIf(); - return createMethodCall(kit, invokeSignature.getReturnType(null), invokeSignature.toParameterTypes(null), newObjectAddress, args); + return createMethodCall(kit, invokeSignature.getReturnType(), invokeSignature.toParameterTypes(null), newObjectAddress, args); } private static ValueNode createMethodCall(JNIGraphKit kit, JavaType returnType, JavaType[] paramTypes, ValueNode methodAddress, ValueNode[] args) { @@ -284,16 +280,16 @@ private static ValueNode mergeValues(JNIGraphKit kit, AbstractMergeNode merge, i return returnValue; } - private static ValueNode[] loadAndUnboxArguments(JNIGraphKit kit, HostedProviders providers, Signature invokeSignature, int firstSlotIndex) { + private static ValueNode[] loadAndUnboxArguments(JNIGraphKit kit, ResolvedSignature invokeSignature, int firstSlotIndex) { int slotIndex = firstSlotIndex; int count = invokeSignature.getParameterCount(false); ValueNode[] args = new ValueNode[count]; for (int i = 0; i < args.length; i++) { - ResolvedJavaType type = (ResolvedJavaType) invokeSignature.getParameterType(i, null); + AnalysisType type = invokeSignature.getParameterType(i); JavaKind kind = type.getJavaKind(); JavaKind loadKind = kind; if (kind.isObject()) { - loadKind = providers.getWordTypes().getWordKind(); + loadKind = kit.getWordTypes().getWordKind(); } else if (kind != kind.getStackKind()) { // We widened the kind in the signature for better reusability of call variant // wrappers (read above) and need to mask extra bits below. diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNINativeCallWrapperMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNINativeCallWrapperMethod.java index 40e26eb3ba01..58b3a71ac3fe 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNINativeCallWrapperMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNINativeCallWrapperMethod.java @@ -30,7 +30,10 @@ import java.util.List; import java.util.function.Function; +import com.oracle.graal.pointsto.infrastructure.ResolvedSignature; import com.oracle.graal.pointsto.infrastructure.WrappedJavaMethod; +import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.AnalysisType; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.core.c.CGlobalDataFactory; import com.oracle.svm.core.graal.code.CGlobalDataInfo; @@ -41,7 +44,6 @@ import com.oracle.svm.core.thread.VMThreads.StatusSupport; import com.oracle.svm.hosted.annotation.CustomSubstitutionMethod; import com.oracle.svm.hosted.c.CGlobalDataFeature; -import com.oracle.svm.hosted.code.SimpleSignature; import com.oracle.svm.hosted.heap.SVMImageHeapScanner; import com.oracle.svm.util.ReflectionUtil; @@ -54,11 +56,8 @@ import jdk.graal.compiler.nodes.java.MonitorExitNode; import jdk.graal.compiler.nodes.java.MonitorIdNode; import jdk.vm.ci.meta.JavaConstant; -import jdk.vm.ci.meta.JavaType; import jdk.vm.ci.meta.LineNumberTable; import jdk.vm.ci.meta.ResolvedJavaMethod; -import jdk.vm.ci.meta.ResolvedJavaType; -import jdk.vm.ci.meta.Signature; /** * Generated code for calling a specific native method from Java code. The wrapper takes care of @@ -106,9 +105,8 @@ public StackTraceElement asStackTraceElement(int bci) { } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { JNIGraphKit kit = new JNIGraphKit(debug, providers, method); - StructuredGraph graph = kit.getGraph(); InvokeWithExceptionNode handleFrame = kit.nativeCallPrologue(); @@ -124,27 +122,27 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, ValueNode environment = kit.environment(); - JavaType javaReturnType = method.getSignature().getReturnType(null); - JavaType[] javaArgumentTypes = method.toParameterTypes(); - List javaArguments = kit.loadArguments(javaArgumentTypes); + AnalysisType javaReturnType = method.getSignature().getReturnType(); + List javaArgumentTypes = method.toParameterList(); + List javaArguments = kit.getInitialArguments(); List jniArguments = new ArrayList<>(2 + javaArguments.size()); - List jniArgumentTypes = new ArrayList<>(2 + javaArguments.size()); - JavaType environmentType = providers.getMetaAccess().lookupJavaType(JNIEnvironment.class); - JavaType objectHandleType = providers.getMetaAccess().lookupJavaType(JNIObjectHandle.class); + List jniArgumentTypes = new ArrayList<>(2 + javaArguments.size()); + AnalysisType environmentType = kit.getMetaAccess().lookupJavaType(JNIEnvironment.class); + AnalysisType objectHandleType = kit.getMetaAccess().lookupJavaType(JNIObjectHandle.class); jniArguments.add(environment); jniArgumentTypes.add(environmentType); if (method.isStatic()) { - JavaConstant clazz = providers.getConstantReflection().asJavaClass(method.getDeclaringClass()); - ConstantNode clazzNode = ConstantNode.forConstant(clazz, providers.getMetaAccess(), graph); + JavaConstant clazz = kit.getConstantReflection().asJavaClass(method.getDeclaringClass()); + ConstantNode clazzNode = ConstantNode.forConstant(clazz, kit.getMetaAccess(), kit.getGraph()); ValueNode box = kit.boxObjectInLocalHandle(clazzNode); jniArguments.add(box); jniArgumentTypes.add(objectHandleType); } for (int i = 0; i < javaArguments.size(); i++) { ValueNode arg = javaArguments.get(i); - JavaType argType = javaArgumentTypes[i]; - if (javaArgumentTypes[i].getJavaKind().isObject()) { + AnalysisType argType = javaArgumentTypes.get(i); + if (argType.getJavaKind().isObject()) { ValueNode obj = javaArguments.get(i); arg = kit.boxObjectInLocalHandle(obj); argType = objectHandleType; @@ -153,7 +151,7 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, jniArgumentTypes.add(argType); } assert jniArguments.size() == jniArgumentTypes.size(); - JavaType jniReturnType = javaReturnType; + AnalysisType jniReturnType = javaReturnType; if (jniReturnType.getJavaKind().isObject()) { jniReturnType = objectHandleType; } @@ -161,12 +159,12 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, if (getOriginal().isSynchronized()) { ValueNode monitorObject; if (method.isStatic()) { - JavaConstant hubConstant = (JavaConstant) providers.getConstantReflection().asObjectHub(method.getDeclaringClass()); - monitorObject = ConstantNode.forConstant(hubConstant, providers.getMetaAccess(), graph); + JavaConstant hubConstant = (JavaConstant) kit.getConstantReflection().asObjectHub(method.getDeclaringClass()); + monitorObject = ConstantNode.forConstant(hubConstant, kit.getMetaAccess(), kit.getGraph()); } else { monitorObject = kit.maybeCreateExplicitNullCheck(javaArguments.get(0)); } - MonitorIdNode monitorId = graph.add(new MonitorIdNode(kit.getFrameState().lockDepth(false))); + MonitorIdNode monitorId = kit.getGraph().add(new MonitorIdNode(kit.getFrameState().lockDepth(false))); MonitorEnterNode monitorEnter = kit.append(new MonitorEnterNode(monitorObject, monitorId)); kit.getFrameState().pushLock(monitorEnter.object(), monitorEnter.getMonitorId()); monitorEnter.setStateAfter(kit.getFrameState().create(kit.bci(), monitorEnter)); @@ -174,7 +172,7 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, kit.getFrameState().clearLocals(); - Signature jniSignature = new SimpleSignature(jniArgumentTypes, jniReturnType); + var jniSignature = ResolvedSignature.fromList(jniArgumentTypes, jniReturnType); ValueNode returnValue = kit.createCFunctionCall(callAddress, jniArguments, jniSignature, StatusSupport.STATUS_IN_NATIVE, false); if (getOriginal().isSynchronized()) { @@ -191,7 +189,7 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, kit.rethrowPendingException(); if (javaReturnType.getJavaKind().isObject()) { // Just before return to always run the epilogue and never suppress a pending exception - returnValue = kit.checkObjectType(returnValue, (ResolvedJavaType) javaReturnType, false); + returnValue = kit.checkObjectType(returnValue, javaReturnType, false); } kit.createReturn(returnValue, javaReturnType.getJavaKind()); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIPrimitiveArrayOperationMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIPrimitiveArrayOperationMethod.java index b83fbd4773aa..9e3cedb3e40b 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIPrimitiveArrayOperationMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIPrimitiveArrayOperationMethod.java @@ -33,6 +33,8 @@ import org.graalvm.nativeimage.c.type.CCharPointer; import org.graalvm.nativeimage.c.type.WordPointer; +import com.oracle.graal.pointsto.infrastructure.ResolvedSignature; +import com.oracle.graal.pointsto.meta.AnalysisMethod; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.core.c.function.CEntryPointOptions.AutomaticPrologueBailout; import com.oracle.svm.core.c.function.CEntryPointOptions.NoEpilogue; @@ -45,19 +47,15 @@ import com.oracle.svm.core.util.VMError; import com.oracle.svm.hosted.code.CEntryPointData; import com.oracle.svm.hosted.code.EntryPointCallStubMethod; -import com.oracle.svm.hosted.code.SimpleSignature; import jdk.graal.compiler.debug.DebugContext; -import jdk.graal.compiler.java.FrameStateBuilder; import jdk.graal.compiler.nodes.FixedWithNextNode; import jdk.graal.compiler.nodes.MergeNode; import jdk.graal.compiler.nodes.StructuredGraph; import jdk.graal.compiler.nodes.ValueNode; import jdk.vm.ci.meta.ConstantPool; import jdk.vm.ci.meta.JavaKind; -import jdk.vm.ci.meta.JavaType; import jdk.vm.ci.meta.MetaAccessProvider; -import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.ResolvedJavaType; /** @@ -148,11 +146,11 @@ private static String createName(JavaKind elementKind, Operation operation) { return sb.toString(); } - private static SimpleSignature createSignature(Operation operation, MetaAccessProvider metaAccess) { + private static ResolvedSignature createSignature(Operation operation, MetaAccessProvider metaAccess) { ResolvedJavaType objectHandleType = metaAccess.lookupJavaType(JNIObjectHandle.class); ResolvedJavaType intType = metaAccess.lookupJavaType(int.class); ResolvedJavaType returnType; - List args = new ArrayList<>(); + List args = new ArrayList<>(); args.add(metaAccess.lookupJavaType(JNIEnvironment.class)); args.add(objectHandleType); // jArray array; if (operation == Operation.GET_ELEMENTS) { @@ -170,21 +168,17 @@ private static SimpleSignature createSignature(Operation operation, MetaAccessPr } else { throw VMError.shouldNotReachHereUnexpectedInput(operation); // ExcludeFromJacocoGeneratedReport } - return new SimpleSignature(args, returnType); + return ResolvedSignature.fromList(args, returnType); } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { JNIGraphKit kit = new JNIGraphKit(debug, providers, method); - StructuredGraph graph = kit.getGraph(); - FrameStateBuilder state = new FrameStateBuilder(null, method, graph); - state.initializeForMethodStart(null, true, providers.getGraphBuilderPlugins()); - ValueNode vmThread = kit.loadLocal(0, getSignature().getParameterKind(0)); + List arguments = kit.getInitialArguments(); + ValueNode vmThread = arguments.get(0); kit.append(CEntryPointEnterNode.enter(vmThread)); - List arguments = kit.loadArguments(getSignature().toParameterTypes(null)); - ValueNode result = null; switch (operation) { case GET_ELEMENTS: { @@ -215,14 +209,14 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, } if (fwn instanceof MergeNode) { MergeNode merge = (MergeNode) fwn; - ((MergeNode) fwn).setStateAfter(state.create(kit.bci(), merge)); + ((MergeNode) fwn).setStateAfter(kit.getFrameState().create(kit.bci(), merge)); } break; } default: throw VMError.shouldNotReachHereUnexpectedInput(operation); // ExcludeFromJacocoGeneratedReport } - kit.appendStateSplitProxy(state); + kit.appendStateSplitProxy(); CEntryPointLeaveNode leave = new CEntryPointLeaveNode(LeaveAction.Leave); kit.append(leave); kit.createReturn(result, (result != null) ? result.getStackKind() : JavaKind.Void); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/meta/HostedMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/meta/HostedMethod.java index 130d135f3f11..0f0ddb28b80d 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/meta/HostedMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/meta/HostedMethod.java @@ -44,11 +44,10 @@ import org.graalvm.nativeimage.Platforms; import com.oracle.graal.pointsto.constraints.UnsupportedFeatureException; -import com.oracle.graal.pointsto.infrastructure.GraphProvider; import com.oracle.graal.pointsto.infrastructure.OriginalMethodProvider; +import com.oracle.graal.pointsto.infrastructure.ResolvedSignature; import com.oracle.graal.pointsto.infrastructure.WrappedJavaMethod; import com.oracle.graal.pointsto.meta.AnalysisMethod; -import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.common.meta.MultiMethod; import com.oracle.svm.core.AlwaysInline; import com.oracle.svm.core.SubstrateUtil; @@ -71,11 +70,10 @@ import com.oracle.svm.hosted.code.SubstrateCompilationDirectives; import jdk.graal.compiler.api.replacements.Snippet; -import jdk.graal.compiler.debug.DebugContext; import jdk.graal.compiler.debug.JavaMethodContext; import jdk.graal.compiler.java.StableMethodNameFormatter; -import jdk.graal.compiler.nodes.StructuredGraph; import jdk.internal.vm.annotation.ForceInline; +import jdk.vm.ci.common.JVMCIError; import jdk.vm.ci.meta.Constant; import jdk.vm.ci.meta.ConstantPool; import jdk.vm.ci.meta.ExceptionHandler; @@ -85,19 +83,17 @@ import jdk.vm.ci.meta.Local; import jdk.vm.ci.meta.LocalVariableTable; import jdk.vm.ci.meta.ProfilingInfo; -import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.ResolvedJavaType; -import jdk.vm.ci.meta.Signature; import jdk.vm.ci.meta.SpeculationLog; -public final class HostedMethod extends HostedElement implements SharedMethod, WrappedJavaMethod, GraphProvider, JavaMethodContext, OriginalMethodProvider, MultiMethod { +public final class HostedMethod extends HostedElement implements SharedMethod, WrappedJavaMethod, JavaMethodContext, OriginalMethodProvider, MultiMethod { public static final String METHOD_NAME_COLLISION_SEPARATOR = "%"; public final AnalysisMethod wrapped; private final HostedType holder; - private final Signature signature; + private final ResolvedSignature signature; private final ConstantPool constantPool; private final ExceptionHandler[] handlers; int vtableIndex = -1; @@ -140,14 +136,14 @@ public final class HostedMethod extends HostedElement implements SharedMethod, W public static final HostedMethod[] EMPTY_ARRAY = new HostedMethod[0]; - static HostedMethod create(HostedUniverse universe, AnalysisMethod wrapped, HostedType holder, Signature signature, + static HostedMethod create(HostedUniverse universe, AnalysisMethod wrapped, HostedType holder, ResolvedSignature signature, ConstantPool constantPool, ExceptionHandler[] handlers) { LocalVariableTable localVariableTable = createLocalVariableTable(universe, wrapped); return create0(wrapped, holder, signature, constantPool, handlers, wrapped.getMultiMethodKey(), null, localVariableTable); } - private static HostedMethod create0(AnalysisMethod wrapped, HostedType holder, Signature signature, + private static HostedMethod create0(AnalysisMethod wrapped, HostedType holder, ResolvedSignature signature, ConstantPool constantPool, ExceptionHandler[] handlers, MultiMethodKey key, Map multiMethodMap, LocalVariableTable localVariableTable) { Function> nameGenerator = (collisionCount) -> { String name = wrapped.wrapped.getName(); // want name w/o any multimethodkey suffix @@ -190,7 +186,7 @@ private static LocalVariableTable createLocalVariableTable(HostedUniverse univer } } - private HostedMethod(AnalysisMethod wrapped, HostedType holder, Signature signature, ConstantPool constantPool, + private HostedMethod(AnalysisMethod wrapped, HostedType holder, ResolvedSignature signature, ConstantPool constantPool, ExceptionHandler[] handlers, String name, String uniqueShortName, LocalVariableTable localVariableTable, MultiMethodKey multiMethodKey, Map multiMethodMap) { this.wrapped = wrapped; @@ -369,18 +365,13 @@ public String getName() { } @Override - public Signature getSignature() { + public ResolvedSignature getSignature() { return signature; } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { - return wrapped.buildGraph(debug, method, providers, purpose); - } - - @Override - public boolean allowRuntimeCompilation() { - return wrapped.allowRuntimeCompilation(); + public JavaType[] toParameterTypes() { + throw JVMCIError.shouldNotReachHere("ResolvedJavaMethod.toParameterTypes returns the wrong result for constructors."); } @Override diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/meta/HostedUniverse.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/meta/HostedUniverse.java index cfbecee9c656..7b575b747bd0 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/meta/HostedUniverse.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/meta/HostedUniverse.java @@ -601,8 +601,8 @@ public int compare(HostedMethod o1, HostedMethod o2) { return result; } - Signature signature1 = o1.getSignature(); - Signature signature2 = o2.getSignature(); + ResolvedSignature signature1 = o1.getSignature(); + ResolvedSignature signature2 = o2.getSignature(); int parameterCount1 = signature1.getParameterCount(false); result = Integer.compare(parameterCount1, signature2.getParameterCount(false)); if (result != 0) { @@ -610,13 +610,13 @@ public int compare(HostedMethod o1, HostedMethod o2) { } for (int i = 0; i < parameterCount1; i++) { - result = typeComparator.compare((HostedType) signature1.getParameterType(i, null), (HostedType) signature2.getParameterType(i, null)); + result = typeComparator.compare(signature1.getParameterType(i), signature2.getParameterType(i)); if (result != 0) { return result; } } - result = typeComparator.compare((HostedType) signature1.getReturnType(null), (HostedType) signature2.getReturnType(null)); + result = typeComparator.compare(signature1.getReturnType(), signature2.getReturnType()); if (result != 0) { return result; } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/meta/UniverseBuilder.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/meta/UniverseBuilder.java index 6ec22dca79c4..9aace5aa2b1a 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/meta/UniverseBuilder.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/meta/UniverseBuilder.java @@ -293,8 +293,7 @@ private static boolean sameObject(Object x, Object y) { private HostedMethod makeMethod(AnalysisMethod aMethod) { AnalysisType aDeclaringClass = aMethod.getDeclaringClass(); HostedType hDeclaringClass = lookupType(aDeclaringClass); - @SuppressWarnings("unchecked") - var signature = makeSignature((ResolvedSignature) aMethod.getSignature()); + ResolvedSignature signature = makeSignature(aMethod.getSignature()); ConstantPool constantPool = makeConstantPool(aMethod.getConstantPool(), aDeclaringClass); ExceptionHandler[] aHandlers = aMethod.getExceptionHandlers(); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceEnumTool.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceEnumTool.java index 16c0f6df0e7b..b62dea3abe53 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceEnumTool.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceEnumTool.java @@ -26,6 +26,13 @@ import java.lang.reflect.Modifier; +import com.oracle.graal.pointsto.meta.AnalysisMetaAccess; +import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.AnalysisType; +import com.oracle.svm.core.c.enums.EnumRuntimeData; +import com.oracle.svm.core.util.VMError; +import com.oracle.svm.hosted.c.info.EnumInfo; + import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.core.common.type.ObjectStamp; import jdk.graal.compiler.core.common.type.StampFactory; @@ -43,19 +50,11 @@ import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderTool; import jdk.graal.compiler.nodes.java.InstanceOfNode; import jdk.graal.compiler.nodes.java.MethodCallTargetNode; - -import com.oracle.svm.core.c.enums.EnumRuntimeData; -import com.oracle.svm.core.util.VMError; -import com.oracle.svm.hosted.c.info.EnumInfo; - import jdk.vm.ci.meta.JavaKind; -import jdk.vm.ci.meta.MetaAccessProvider; -import jdk.vm.ci.meta.ResolvedJavaMethod; -import jdk.vm.ci.meta.ResolvedJavaType; public class CInterfaceEnumTool { interface CallTargetFactory { - MethodCallTargetNode createMethodCallTarget(InvokeKind invokeKind, ResolvedJavaMethod targetMethod, ValueNode[] args, StampPair returnStamp, int bci); + MethodCallTargetNode createMethodCallTarget(InvokeKind invokeKind, AnalysisMethod targetMethod, ValueNode[] args, StampPair returnStamp, int bci); static CallTargetFactory from(BytecodeParser p) { return (invokeKind, targetMethod, args, returnStamp, bci) -> p.createMethodCallTarget(invokeKind, targetMethod, args, returnStamp, null); @@ -67,11 +66,11 @@ static CallTargetFactory from(HostedGraphKit kit) { } private final SnippetReflectionProvider snippetReflection; - private final ResolvedJavaMethod convertJavaToCLongMethod; - private final ResolvedJavaMethod convertJavaToCIntMethod; - private final ResolvedJavaMethod convertCToJavaMethod; + private final AnalysisMethod convertJavaToCLongMethod; + private final AnalysisMethod convertJavaToCIntMethod; + private final AnalysisMethod convertCToJavaMethod; - public CInterfaceEnumTool(MetaAccessProvider metaAccess, SnippetReflectionProvider snippetReflection) { + public CInterfaceEnumTool(AnalysisMetaAccess metaAccess, SnippetReflectionProvider snippetReflection) { this.snippetReflection = snippetReflection; try { convertJavaToCLongMethod = metaAccess.lookupJavaMethod(EnumRuntimeData.class.getDeclaredMethod("convertJavaToCLong", Enum.class)); @@ -82,7 +81,7 @@ public CInterfaceEnumTool(MetaAccessProvider metaAccess, SnippetReflectionProvid } } - private ResolvedJavaMethod getValueMethodForKind(JavaKind kind) { + private AnalysisMethod getValueMethodForKind(JavaKind kind) { return (kind == JavaKind.Long) ? convertJavaToCLongMethod : convertJavaToCIntMethod; } @@ -99,8 +98,8 @@ public ValueNode startEnumValueInvokeWithException(HostedGraphKit kit, EnumInfo } private MethodCallTargetNode invokeEnumValue(GraphBuilderTool b, CallTargetFactory callTargetFactory, int bci, EnumInfo enumInfo, JavaKind resultKind, ValueNode arg) { - ResolvedJavaMethod valueMethod = getValueMethodForKind(resultKind); - ResolvedJavaType returnType = (ResolvedJavaType) valueMethod.getSignature().getReturnType(null); + AnalysisMethod valueMethod = getValueMethodForKind(resultKind); + AnalysisType returnType = valueMethod.getSignature().getReturnType(); ValueNode[] args = new ValueNode[2]; args[0] = ConstantNode.forConstant(snippetReflection.forObject(enumInfo.getRuntimeData()), b.getMetaAccess(), b.getGraph()); args[1] = arg; @@ -109,7 +108,7 @@ private MethodCallTargetNode invokeEnumValue(GraphBuilderTool b, CallTargetFacto return b.append(callTargetFactory.createMethodCallTarget(InvokeKind.Virtual, valueMethod, args, returnStamp, bci)); } - public ValueNode createEnumLookupInvoke(HostedGraphKit kit, ResolvedJavaType enumType, EnumInfo enumInfo, JavaKind parameterKind, ValueNode arg) { + public ValueNode createEnumLookupInvoke(HostedGraphKit kit, AnalysisType enumType, EnumInfo enumInfo, JavaKind parameterKind, ValueNode arg) { // Create the invoke to the actual target method: EnumRuntimeData.convertCToJava int invokeBci = kit.bci(); MethodCallTargetNode callTarget = invokeEnumLookup(kit, CallTargetFactory.from(kit), invokeBci, enumInfo, parameterKind, arg); @@ -129,10 +128,10 @@ private MethodCallTargetNode invokeEnumLookup(GraphBuilderTool b, CallTargetFact ValueNode[] args = new ValueNode[2]; args[0] = ConstantNode.forConstant(snippetReflection.forObject(enumInfo.getRuntimeData()), b.getMetaAccess(), b.getGraph()); assert !Modifier.isStatic(convertCToJavaMethod.getModifiers()) && convertCToJavaMethod.getSignature().getParameterCount(false) == 1; - JavaKind expectedKind = convertCToJavaMethod.getSignature().getParameterType(0, null).getJavaKind(); + JavaKind expectedKind = convertCToJavaMethod.getSignature().getParameterType(0).getJavaKind(); args[1] = CInterfaceInvocationPlugin.adaptPrimitiveType(b.getGraph(), arg, parameterKind, expectedKind, false); - ResolvedJavaType convertReturnType = (ResolvedJavaType) convertCToJavaMethod.getSignature().getReturnType(null); + AnalysisType convertReturnType = convertCToJavaMethod.getSignature().getReturnType(); StampPair returnStamp = StampFactory.forDeclaredType(null, convertReturnType, false); return b.append(callTargetFactory.createMethodCallTarget(InvokeKind.Virtual, convertCToJavaMethod, args, returnStamp, bci)); } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceInvocationPlugin.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceInvocationPlugin.java index 596cf4254251..5f5383dd2ff2 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceInvocationPlugin.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/CInterfaceInvocationPlugin.java @@ -35,6 +35,7 @@ import org.graalvm.word.LocationIdentity; import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.AnalysisType; import com.oracle.svm.core.FrameAccess; import com.oracle.svm.core.c.InvokeJavaFunctionPointer; import com.oracle.svm.core.c.struct.CInterfaceLocationIdentity; @@ -56,8 +57,6 @@ import com.oracle.svm.hosted.code.CEntryPointCallStubSupport; import com.oracle.svm.hosted.code.CEntryPointJavaCallStubMethod; import com.oracle.svm.hosted.code.CFunctionPointerCallStubSupport; -import com.oracle.svm.hosted.meta.HostedMetaAccess; -import com.oracle.svm.hosted.meta.HostedMethod; import jdk.graal.compiler.api.replacements.SnippetReflectionProvider; import jdk.graal.compiler.core.common.calc.FloatConvert; @@ -111,7 +110,8 @@ public CInterfaceInvocationPlugin(MetaAccessProvider metaAccess, SnippetReflecti } @Override - public boolean handleInvoke(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args) { + public boolean handleInvoke(GraphBuilderContext b, ResolvedJavaMethod m, ValueNode[] args) { + AnalysisMethod method = (AnalysisMethod) m; ElementInfo methodInfo = nativeLibs.findElementInfo(method); if (methodInfo instanceof AccessorInfo) { ElementInfo parentInfo = methodInfo.getParent(); @@ -136,13 +136,8 @@ public boolean handleInvoke(GraphBuilderContext b, ResolvedJavaMethod method, Va } else if (method.getAnnotation(InvokeJavaFunctionPointer.class) != null) { return replaceJavaFunctionPointerInvoke(b, method, args); } else if (method.getAnnotation(CEntryPoint.class) != null) { - AnalysisMethod aMethod = (AnalysisMethod) (method instanceof HostedMethod ? ((HostedMethod) method).getWrapped() : method); - assert !(aMethod.getWrapped() instanceof CEntryPointJavaCallStubMethod) : "Call stub should never have a @CEntryPoint annotation"; - ResolvedJavaMethod stub = CEntryPointCallStubSupport.singleton().registerJavaStubForMethod(aMethod); - if (method instanceof HostedMethod) { - HostedMetaAccess hMetaAccess = (HostedMetaAccess) b.getMetaAccess(); - stub = hMetaAccess.getUniverse().lookup(stub); - } + assert !(method.getWrapped() instanceof CEntryPointJavaCallStubMethod) : "Call stub should never have a @CEntryPoint annotation"; + AnalysisMethod stub = CEntryPointCallStubSupport.singleton().registerJavaStubForMethod(method); assert !b.getMethod().equals(stub) : "Plugin should not be called for the invoke in the stub itself"; b.handleReplacedInvoke(InvokeKind.Static, stub, args, false); return true; @@ -151,7 +146,7 @@ public boolean handleInvoke(GraphBuilderContext b, ResolvedJavaMethod method, Va } } - private boolean replaceOffsetOf(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args, AccessorInfo accessorInfo, int displacement) { + private boolean replaceOffsetOf(GraphBuilderContext b, AnalysisMethod method, ValueNode[] args, AccessorInfo accessorInfo, int displacement) { /* * A method annotated with @OffsetOf can be static, but does not need to be. If it is * non-static, we just ignore the receiver. @@ -163,7 +158,7 @@ private boolean replaceOffsetOf(GraphBuilderContext b, ResolvedJavaMethod method return true; } - private boolean replaceAccessor(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args, AccessorInfo accessorInfo, int displacement) { + private boolean replaceAccessor(GraphBuilderContext b, AnalysisMethod method, ValueNode[] args, AccessorInfo accessorInfo, int displacement) { StructuredGraph graph = b.getGraph(); SizableInfo sizableInfo = (SizableInfo) accessorInfo.getParent(); int elementSize = sizableInfo.getSizeInfo().getProperty(); @@ -228,7 +223,7 @@ private boolean replaceAccessor(GraphBuilderContext b, ResolvedJavaMethod method } } - private boolean replaceBitfieldAccessor(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args, StructBitfieldInfo bitfieldInfo, AccessorInfo accessorInfo) { + private boolean replaceBitfieldAccessor(GraphBuilderContext b, AnalysisMethod method, ValueNode[] args, StructBitfieldInfo bitfieldInfo, AccessorInfo accessorInfo) { int byteOffset = bitfieldInfo.getByteOffsetInfo().getProperty(); int startBit = bitfieldInfo.getStartBitInfo().getProperty(); int endBit = bitfieldInfo.getEndBitInfo().getProperty(); @@ -385,7 +380,7 @@ private static AddressNode makeOffsetAddress(StructuredGraph graph, ValueNode[] return graph.addOrUniqueWithInputs(new OffsetAddressNode(base, makeOffset(graph, args, accessorInfo, displacement, indexScaling))); } - private static LocationIdentity makeLocationIdentity(GraphBuilderContext b, SnippetReflectionProvider snippetReflection, ResolvedJavaMethod method, ValueNode[] args, AccessorInfo accessorInfo) { + private static LocationIdentity makeLocationIdentity(GraphBuilderContext b, SnippetReflectionProvider snippetReflection, AnalysisMethod method, ValueNode[] args, AccessorInfo accessorInfo) { LocationIdentity locationIdentity; if (accessorInfo.hasLocationIdentityParameter()) { ValueNode locationIdentityNode = args[accessorInfo.locationIdentityParameterNumber(true)]; @@ -467,7 +462,7 @@ private static JavaKind kindFromSize(int sizeInBytes, JavaKind matchingKind) { throw shouldNotReachHere("Unsupported size: " + sizeInBytes); } - private boolean replaceConstant(GraphBuilderContext b, ResolvedJavaMethod method, ConstantInfo constantInfo) { + private boolean replaceConstant(GraphBuilderContext b, AnalysisMethod method, ConstantInfo constantInfo) { Object value = constantInfo.getValueInfo().getProperty(); JavaKind kind = b.getWordTypes().asKind(b.getInvokeReturnType()); @@ -495,10 +490,8 @@ private boolean replaceConstant(GraphBuilderContext b, ResolvedJavaMethod method return true; } - private boolean replaceCFunctionPointerInvoke(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args) { - boolean hosted = method instanceof HostedMethod; - AnalysisMethod aMethod = (AnalysisMethod) (hosted ? ((HostedMethod) method).getWrapped() : method); - if (CFunctionPointerCallStubSupport.singleton().isStub(aMethod)) { + private boolean replaceCFunctionPointerInvoke(GraphBuilderContext b, AnalysisMethod method, ValueNode[] args) { + if (CFunctionPointerCallStubSupport.singleton().isStub(method)) { return false; } if (!functionPointerType.isAssignableFrom(method.getDeclaringClass())) { @@ -506,15 +499,12 @@ private boolean replaceCFunctionPointerInvoke(GraphBuilderContext b, ResolvedJav " must be in a type that extends " + CFunctionPointer.class.getSimpleName(), method).getMessage()); } assert b.getInvokeKind() == InvokeKind.Interface; - ResolvedJavaMethod stub = CFunctionPointerCallStubSupport.singleton().getOrCreateStubForMethod(aMethod); - if (hosted) { - stub = ((HostedMetaAccess) b.getMetaAccess()).getUniverse().lookup(stub); - } + AnalysisMethod stub = CFunctionPointerCallStubSupport.singleton().getOrCreateStubForMethod(method); b.handleReplacedInvoke(InvokeKind.Static, stub, args, false); return true; } - private boolean replaceJavaFunctionPointerInvoke(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args) { + private boolean replaceJavaFunctionPointerInvoke(GraphBuilderContext b, AnalysisMethod method, ValueNode[] args) { if (!functionPointerType.isAssignableFrom(method.getDeclaringClass())) { throw UserError.abort(new CInterfaceError("Function pointer invocation method " + method.format("%H.%n(%p)") + " must be in a type that extends " + CFunctionPointer.class.getSimpleName(), method).getMessage()); @@ -530,7 +520,7 @@ private boolean replaceJavaFunctionPointerInvoke(GraphBuilderContext b, Resolved Stamp returnStamp; if (b.getWordTypes().isWord(b.getInvokeReturnType())) { - returnStamp = b.getWordTypes().getWordStamp((ResolvedJavaType) b.getInvokeReturnType()); + returnStamp = b.getWordTypes().getWordStamp((AnalysisType) b.getInvokeReturnType()); } else { returnStamp = b.getInvokeReturnStamp(null).getTrustedStamp(); } @@ -541,7 +531,7 @@ private boolean replaceJavaFunctionPointerInvoke(GraphBuilderContext b, Resolved return true; } - public static JavaKind pushKind(ResolvedJavaMethod method) { + public static JavaKind pushKind(AnalysisMethod method) { return method.getSignature().getReturnKind().getStackKind(); } } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/InjectedAccessorsPlugin.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/InjectedAccessorsPlugin.java index 060804123006..acac1156467f 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/InjectedAccessorsPlugin.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/InjectedAccessorsPlugin.java @@ -27,56 +27,57 @@ import java.util.ArrayList; import java.util.List; +import com.oracle.graal.pointsto.meta.AnalysisField; +import com.oracle.graal.pointsto.meta.AnalysisMetaAccess; +import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.AnalysisType; +import com.oracle.svm.core.annotate.InjectAccessors; +import com.oracle.svm.core.util.VMError; + import jdk.graal.compiler.nodes.CallTargetNode.InvokeKind; import jdk.graal.compiler.nodes.ValueNode; import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderContext; import jdk.graal.compiler.nodes.graphbuilderconf.NodePlugin; - -import com.oracle.svm.core.annotate.InjectAccessors; -import com.oracle.svm.core.util.VMError; - -import jdk.vm.ci.meta.JavaType; import jdk.vm.ci.meta.ResolvedJavaField; -import jdk.vm.ci.meta.ResolvedJavaMethod; -import jdk.vm.ci.meta.ResolvedJavaType; public final class InjectedAccessorsPlugin implements NodePlugin { @Override public boolean handleLoadField(GraphBuilderContext b, ValueNode object, ResolvedJavaField field) { - return handleField(b, field, false, object, true, null); + return handleField(b, (AnalysisField) field, false, object, true, null); } @Override public boolean handleLoadStaticField(GraphBuilderContext b, ResolvedJavaField field) { - return handleField(b, field, true, null, true, null); + return handleField(b, (AnalysisField) field, true, null, true, null); } @Override public boolean handleStoreField(GraphBuilderContext b, ValueNode object, ResolvedJavaField field, ValueNode value) { - return handleField(b, field, false, object, false, value); + return handleField(b, (AnalysisField) field, false, object, false, value); } @Override public boolean handleStoreStaticField(GraphBuilderContext b, ResolvedJavaField field, ValueNode value) { - return handleField(b, field, true, null, false, value); + return handleField(b, (AnalysisField) field, true, null, false, value); } - private static boolean handleField(GraphBuilderContext b, ResolvedJavaField field, boolean isStatic, ValueNode receiver, boolean isGet, ValueNode value) { + private static boolean handleField(GraphBuilderContext b, AnalysisField field, boolean isStatic, ValueNode receiver, boolean isGet, ValueNode value) { InjectAccessors injectAccesors = field.getAnnotation(InjectAccessors.class); if (injectAccesors == null) { return false; } + var metaAccess = (AnalysisMetaAccess) b.getMetaAccess(); Class accessorsClass = injectAccesors.value(); - ResolvedJavaType accessorsType = b.getMetaAccess().lookupJavaType(accessorsClass); + AnalysisType accessorsType = metaAccess.lookupJavaType(accessorsClass); String shortName = isGet ? "get" : "set"; String fieldName = field.getName(); String longName = shortName + Character.toUpperCase(fieldName.charAt(0)) + fieldName.substring(1); - ResolvedJavaMethod foundMethod = null; - for (ResolvedJavaMethod method : accessorsType.getDeclaredMethods(false)) { + AnalysisMethod foundMethod = null; + for (AnalysisMethod method : accessorsType.getDeclaredMethods(false)) { if (method.getName().equals(shortName) || method.getName().equals(longName)) { if (foundMethod != null) { error(field, accessorsType, null, "found two methods " + foundMethod.format("%n(%p)") + " and " + method.format("%n(%p)")); @@ -98,10 +99,10 @@ private static boolean handleField(GraphBuilderContext b, ResolvedJavaField fiel error(field, accessorsType, foundMethod, "not enough parameters"); } - JavaType actualReceiver = foundMethod.getSignature().getParameterType(paramIdx, null); - ResolvedJavaType expectedReceiver = field.getDeclaringClass(); + AnalysisType actualReceiver = foundMethod.getSignature().getParameterType(paramIdx); + AnalysisType expectedReceiver = field.getDeclaringClass(); boolean match = false; - for (ResolvedJavaType cur = expectedReceiver; cur != null; cur = cur.getSuperclass()) { + for (AnalysisType cur = expectedReceiver; cur != null; cur = cur.getSuperclass()) { if (actualReceiver.equals(cur)) { match = true; break; @@ -113,9 +114,9 @@ private static boolean handleField(GraphBuilderContext b, ResolvedJavaField fiel paramIdx++; } - JavaType expectedValue = field.getType(); + AnalysisType expectedValue = field.getType(); if (isGet) { - JavaType actualValue = foundMethod.getSignature().getReturnType(null); + AnalysisType actualValue = foundMethod.getSignature().getReturnType(); if (!actualValue.equals(expectedValue)) { error(field, accessorsType, foundMethod, "wrong return type: expected " + expectedValue.toJavaName(true) + ", found " + actualValue.toJavaName(true)); } @@ -125,7 +126,7 @@ private static boolean handleField(GraphBuilderContext b, ResolvedJavaField fiel error(field, accessorsType, foundMethod, "not enough parameters"); } - JavaType actualValue = foundMethod.getSignature().getParameterType(paramIdx, null); + AnalysisType actualValue = foundMethod.getSignature().getParameterType(paramIdx); if (!actualValue.equals(expectedValue)) { error(field, accessorsType, foundMethod, "wrong value type: expected " + expectedValue.toJavaName(true) + ", found " + actualValue.toJavaName(true)); } @@ -148,7 +149,7 @@ private static boolean handleField(GraphBuilderContext b, ResolvedJavaField fiel return true; } - private static void error(ResolvedJavaField field, ResolvedJavaType accessorsType, ResolvedJavaMethod method, String msg) { + private static void error(AnalysisField field, AnalysisType accessorsType, AnalysisMethod method, String msg) { throw VMError.shouldNotReachHere("Error in @" + InjectAccessors.class.getSimpleName() + " handling of field " + field.format("%H.%n") + ", accessors class " + accessorsType.toJavaName(true) + (method == null ? "" : ", method " + method.format("%n(%p)")) + ": " + msg); } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/InlineBeforeAnalysisPolicyImpl.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/InlineBeforeAnalysisPolicyImpl.java index 92129f854ccf..85f5563d6b47 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/InlineBeforeAnalysisPolicyImpl.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/InlineBeforeAnalysisPolicyImpl.java @@ -25,6 +25,7 @@ package com.oracle.svm.hosted.phases; import com.oracle.graal.pointsto.meta.AnalysisMetaAccess; +import com.oracle.graal.pointsto.meta.AnalysisMethod; import com.oracle.graal.pointsto.phases.InlineBeforeAnalysisPolicy; import com.oracle.svm.core.ParsingReason; import com.oracle.svm.hosted.SVMHost; @@ -35,7 +36,6 @@ import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderContext; import jdk.graal.compiler.nodes.graphbuilderconf.InlineInvokePlugin.InlineInfo; import jdk.graal.compiler.nodes.graphbuilderconf.NodePlugin; -import jdk.vm.ci.meta.ResolvedJavaMethod; /** * The defaults for node limits are very conservative. Only small methods should be inlined. The @@ -65,7 +65,7 @@ public InlineBeforeAnalysisPolicyImpl(SVMHost hostVM, InlineBeforeAnalysisPolicy } @Override - protected boolean shouldInlineInvoke(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args) { + protected boolean shouldInlineInvoke(GraphBuilderContext b, AnalysisMethod method, ValueNode[] args) { if (inliningUtils.alwaysInlineInvoke((AnalysisMetaAccess) b.getMetaAccess(), method)) { return true; } @@ -81,7 +81,7 @@ protected boolean shouldInlineInvoke(GraphBuilderContext b, ResolvedJavaMethod m } @Override - protected InlineInfo createInvokeInfo(ResolvedJavaMethod method) { + protected InlineInfo createInvokeInfo(AnalysisMethod method) { return InlineInfo.createStandardInlineInfo(method); } @@ -107,17 +107,17 @@ protected AbstractPolicyScope createRootScope() { @Override protected AbstractPolicyScope openCalleeScope(AbstractPolicyScope outer, AnalysisMetaAccess metaAccess, - ResolvedJavaMethod method, boolean[] constArgsWithReceiver, boolean intrinsifiedMethodHandle) { + AnalysisMethod method, boolean[] constArgsWithReceiver, boolean intrinsifiedMethodHandle) { return inliningUtils.createAccumulativeInlineScope((InlineBeforeAnalysisPolicyUtils.AccumulativeInlineScope) outer, metaAccess, method, constArgsWithReceiver, intrinsifiedMethodHandle); } @Override - protected boolean shouldOmitIntermediateMethodInState(ResolvedJavaMethod method) { + protected boolean shouldOmitIntermediateMethodInState(AnalysisMethod method) { return inliningUtils.shouldOmitIntermediateMethodInState(method); } @Override - protected FixedWithNextNode processInvokeArgs(ResolvedJavaMethod targetMethod, FixedWithNextNode insertionPoint, ValueNode[] arguments, NodeSourcePosition sourcePosition) { + protected FixedWithNextNode processInvokeArgs(AnalysisMethod targetMethod, FixedWithNextNode insertionPoint, ValueNode[] arguments, NodeSourcePosition sourcePosition) { // No action is needed return insertionPoint; } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/InlineBeforeAnalysisPolicyUtils.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/InlineBeforeAnalysisPolicyUtils.java index 9aecd9816ca3..3fe948fee521 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/InlineBeforeAnalysisPolicyUtils.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/InlineBeforeAnalysisPolicyUtils.java @@ -30,6 +30,23 @@ import java.util.Map; import java.util.Set; +import org.graalvm.nativeimage.AnnotationAccess; + +import com.oracle.graal.pointsto.infrastructure.OriginalClassProvider; +import com.oracle.graal.pointsto.meta.AnalysisMetaAccess; +import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.AnalysisType; +import com.oracle.graal.pointsto.phases.InlineBeforeAnalysisPolicy; +import com.oracle.svm.core.Uninterruptible; +import com.oracle.svm.core.heap.RestrictHeapAccess; +import com.oracle.svm.core.jdk.VarHandleFeature; +import com.oracle.svm.core.option.HostedOptionKey; +import com.oracle.svm.core.util.VMError; +import com.oracle.svm.hosted.ReachabilityRegistrationNode; +import com.oracle.svm.hosted.SVMHost; +import com.oracle.svm.hosted.methodhandles.MethodHandleInvokerRenamingSubstitutionProcessor; +import com.oracle.svm.util.ReflectionUtil; + import jdk.graal.compiler.api.replacements.Fold; import jdk.graal.compiler.graph.Node; import jdk.graal.compiler.nodes.AbstractBeginNode; @@ -56,25 +73,6 @@ import jdk.graal.compiler.nodes.virtual.VirtualObjectNode; import jdk.graal.compiler.options.Option; import jdk.graal.compiler.replacements.nodes.MethodHandleWithExceptionNode; -import org.graalvm.nativeimage.AnnotationAccess; - -import com.oracle.graal.pointsto.infrastructure.OriginalClassProvider; -import com.oracle.graal.pointsto.meta.AnalysisMetaAccess; -import com.oracle.graal.pointsto.meta.AnalysisMethod; -import com.oracle.graal.pointsto.meta.AnalysisType; -import com.oracle.graal.pointsto.phases.InlineBeforeAnalysisPolicy; -import com.oracle.svm.core.Uninterruptible; -import com.oracle.svm.core.heap.RestrictHeapAccess; -import com.oracle.svm.core.jdk.VarHandleFeature; -import com.oracle.svm.core.option.HostedOptionKey; -import com.oracle.svm.core.util.VMError; -import com.oracle.svm.hosted.ReachabilityRegistrationNode; -import com.oracle.svm.hosted.SVMHost; -import com.oracle.svm.hosted.methodhandles.MethodHandleInvokerRenamingSubstitutionProcessor; -import com.oracle.svm.util.ReflectionUtil; - -import jdk.vm.ci.meta.ResolvedJavaMethod; -import jdk.vm.ci.meta.ResolvedJavaType; public class InlineBeforeAnalysisPolicyUtils { public static class Options { @@ -108,9 +106,8 @@ public static class Options { private AnalysisType methodHandleType; private AnalysisType varHandleGuardsType; - public static boolean inliningAllowed(SVMHost hostVM, GraphBuilderContext b, ResolvedJavaMethod method) { + public static boolean inliningAllowed(SVMHost hostVM, GraphBuilderContext b, AnalysisMethod callee) { AnalysisMethod caller = (AnalysisMethod) b.getMethod(); - AnalysisMethod callee = (AnalysisMethod) method; if (hostVM.neverInlineTrivial(caller, callee)) { return false; } @@ -143,7 +140,7 @@ public static boolean inliningAllowed(SVMHost hostVM, GraphBuilderContext b, Res return true; } - public boolean alwaysInlineInvoke(@SuppressWarnings("unused") AnalysisMetaAccess metaAccess, @SuppressWarnings("unused") ResolvedJavaMethod method) { + public boolean alwaysInlineInvoke(@SuppressWarnings("unused") AnalysisMetaAccess metaAccess, @SuppressWarnings("unused") AnalysisMethod method) { return false; } @@ -173,7 +170,7 @@ public void abortCalleeScope(InlineBeforeAnalysisPolicy.AbstractPolicyScope call } @Override - public boolean processNode(AnalysisMetaAccess metaAccess, ResolvedJavaMethod method, Node node) { + public boolean processNode(AnalysisMetaAccess metaAccess, AnalysisMethod method, Node node) { // always inlining return true; } @@ -222,7 +219,7 @@ private AccumulativeCounters(int maxNodes, int maxInvokes, int maxInliningDepth, * aborted. */ public AccumulativeInlineScope createAccumulativeInlineScope(AccumulativeInlineScope outer, AnalysisMetaAccess metaAccess, - ResolvedJavaMethod method, boolean[] constArgsWithReceiver, boolean intrinsifiedMethodHandle) { + AnalysisMethod method, boolean[] constArgsWithReceiver, boolean intrinsifiedMethodHandle) { AccumulativeCounters accumulativeCounters; int depth; if (outer == null) { @@ -264,11 +261,11 @@ public AccumulativeInlineScope createAccumulativeInlineScope(AccumulativeInlineS return new AccumulativeInlineScope(accumulativeCounters, depth); } - private boolean isMethodHandleIntrinsificationRoot(AnalysisMetaAccess metaAccess, ResolvedJavaMethod method, boolean[] constArgsWithReceiver) { + private boolean isMethodHandleIntrinsificationRoot(AnalysisMetaAccess metaAccess, AnalysisMethod method, boolean[] constArgsWithReceiver) { return (isVarHandleMethod(metaAccess, method) || hasConstantMethodHandleParameter(metaAccess, method, constArgsWithReceiver)) && !isIgnoredMethodHandleMethod(method); } - private boolean hasConstantMethodHandleParameter(AnalysisMetaAccess metaAccess, ResolvedJavaMethod method, boolean[] constArgsWithReceiver) { + private boolean hasConstantMethodHandleParameter(AnalysisMetaAccess metaAccess, AnalysisMethod method, boolean[] constArgsWithReceiver) { if (methodHandleType == null) { methodHandleType = metaAccess.lookupJavaType(MethodHandle.class); } @@ -280,7 +277,7 @@ private boolean hasConstantMethodHandleParameter(AnalysisMetaAccess metaAccess, return false; } - private static ResolvedJavaType getParameterType(ResolvedJavaMethod method, int index) { + private static AnalysisType getParameterType(AnalysisMethod method, int index) { int i = index; if (!method.isStatic()) { if (i == 0) { // receiver @@ -288,7 +285,7 @@ private static ResolvedJavaType getParameterType(ResolvedJavaMethod method, int } i--; } - return (ResolvedJavaType) method.getSignature().getParameterType(i, null); + return method.getSignature().getParameterType(i); } /** @@ -299,14 +296,14 @@ private static ResolvedJavaType getParameterType(ResolvedJavaMethod method, int * See the documentation in {@link VarHandleFeature} for more information on the overall * VarHandle support. */ - private boolean isVarHandleMethod(AnalysisMetaAccess metaAccess, ResolvedJavaMethod method) { + private boolean isVarHandleMethod(AnalysisMetaAccess metaAccess, AnalysisMethod method) { if (varHandleGuardsType == null) { varHandleGuardsType = metaAccess.lookupJavaType(ReflectionUtil.lookupClass(false, "java.lang.invoke.VarHandleGuards")); } return method.getDeclaringClass().equals(varHandleGuardsType); } - private static boolean isIgnoredMethodHandleMethod(ResolvedJavaMethod method) { + private static boolean isIgnoredMethodHandleMethod(AnalysisMethod method) { Class declaringClass = OriginalClassProvider.getJavaClass(method.getDeclaringClass()); Set ignoredMethods = IGNORED_METHOD_HANDLE_METHODS.get(declaringClass); return ignoredMethods != null && ignoredMethods.contains(method.getName()); @@ -363,7 +360,7 @@ public void abortCalleeScope(InlineBeforeAnalysisPolicy.AbstractPolicyScope call } @Override - public boolean processNode(AnalysisMetaAccess metaAccess, ResolvedJavaMethod method, Node node) { + public boolean processNode(AnalysisMetaAccess metaAccess, AnalysisMethod method, Node node) { if (node instanceof StartNode || node instanceof ParameterNode || node instanceof ReturnNode || node instanceof UnwindNode || node instanceof CallTargetNode || node instanceof MethodHandleWithExceptionNode) { /* @@ -471,7 +468,7 @@ public String toString() { } } - private static boolean inlineForMethodHandleIntrinsification(ResolvedJavaMethod method) { + private static boolean inlineForMethodHandleIntrinsification(AnalysisMethod method) { String className = method.getDeclaringClass().toJavaName(true); if (className.startsWith("java.lang.invoke") && !className.contains("InvokerBytecodeGenerator")) { /* @@ -493,7 +490,7 @@ private static boolean inlineForMethodHandleIntrinsification(ResolvedJavaMethod * * @see MethodHandleInvokerRenamingSubstitutionProcessor */ - protected boolean shouldOmitIntermediateMethodInState(ResolvedJavaMethod method) { + protected boolean shouldOmitIntermediateMethodInState(AnalysisMethod method) { return method.isAnnotationPresent(COMPILED_LAMBDA_FORM_ANNOTATION); } } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionExpandSignatureMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionExpandSignatureMethod.java index c7729a701ed0..209788203da8 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionExpandSignatureMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionExpandSignatureMethod.java @@ -24,6 +24,15 @@ */ package com.oracle.svm.hosted.reflect; +import com.oracle.graal.pointsto.meta.AnalysisMethod; +import com.oracle.graal.pointsto.meta.AnalysisType; +import com.oracle.graal.pointsto.meta.HostedProviders; +import com.oracle.svm.core.graal.code.SubstrateCallingConventionKind; +import com.oracle.svm.core.reflect.ReflectionAccessorHolder.MethodInvokeFunctionPointer; +import com.oracle.svm.core.reflect.SubstrateConstructorAccessor; +import com.oracle.svm.core.reflect.SubstrateMethodAccessor; +import com.oracle.svm.hosted.code.NonBytecodeMethod; + import jdk.graal.compiler.core.common.type.StampFactory; import jdk.graal.compiler.core.common.type.StampPair; import jdk.graal.compiler.debug.DebugContext; @@ -33,14 +42,6 @@ import jdk.graal.compiler.nodes.InvokeWithExceptionNode; import jdk.graal.compiler.nodes.StructuredGraph; import jdk.graal.compiler.nodes.ValueNode; - -import com.oracle.graal.pointsto.meta.HostedProviders; -import com.oracle.svm.core.graal.code.SubstrateCallingConventionKind; -import com.oracle.svm.core.reflect.ReflectionAccessorHolder.MethodInvokeFunctionPointer; -import com.oracle.svm.core.reflect.SubstrateConstructorAccessor; -import com.oracle.svm.core.reflect.SubstrateMethodAccessor; -import com.oracle.svm.hosted.code.NonBytecodeMethod; - import jdk.vm.ci.meta.JavaKind; import jdk.vm.ci.meta.ResolvedJavaMethod; import jdk.vm.ci.meta.ResolvedJavaType; @@ -75,18 +76,18 @@ public ReflectionExpandSignatureMethod(String name, ResolvedJavaMethod prototype * in different classes. */ @Override - public StructuredGraph buildGraph(DebugContext ctx, ResolvedJavaMethod m, HostedProviders providers, Purpose purpose) { - ReflectionGraphKit graphKit = new ReflectionGraphKit(ctx, providers, m, purpose); + public StructuredGraph buildGraph(DebugContext ctx, AnalysisMethod method, HostedProviders providers, Purpose purpose) { + ReflectionGraphKit kit = new ReflectionGraphKit(ctx, providers, method, purpose); - ValueNode receiver = graphKit.loadLocal(0, JavaKind.Object); - ValueNode argumentArray = graphKit.loadLocal(1, JavaKind.Object); + ValueNode receiver = kit.loadLocal(0, JavaKind.Object); + ValueNode argumentArray = kit.loadLocal(1, JavaKind.Object); /* The invokedMethod is a Word type, so not yet a primitive in the signature. */ - ValueNode invokedMethod = graphKit.loadLocal(2, JavaKind.Object); + ValueNode invokedMethod = kit.loadLocal(2, JavaKind.Object); /* Caller-sensitive-adapter methods have an additional Class parameter. */ - ValueNode callerClass = callerSensitiveAdapter ? graphKit.loadLocal(3, JavaKind.Object) : null; + ValueNode callerClass = callerSensitiveAdapter ? kit.loadLocal(3, JavaKind.Object) : null; /* Clear all locals, so that they are not alive and spilled at method calls. */ - graphKit.getFrameState().clearLocals(); + kit.getFrameState().clearLocals(); int receiverOffset = isStatic ? 0 : 1; int argsCount = argTypes.length + receiverOffset + (callerSensitiveAdapter ? 1 : 0); @@ -97,42 +98,42 @@ public StructuredGraph buildGraph(DebugContext ctx, ResolvedJavaMethod m, Hosted * The receiver is already null-checked and type-checked at the call site in * SubstrateMethodAccessor. */ - signature[0] = providers.getMetaAccess().lookupJavaType(Object.class); + signature[0] = kit.getMetaAccess().lookupJavaType(Object.class); args[0] = receiver; } if (callerSensitiveAdapter) { - signature[argsCount - 1] = providers.getMetaAccess().lookupJavaType(Class.class); + signature[argsCount - 1] = kit.getMetaAccess().lookupJavaType(Class.class); args[argsCount - 1] = callerClass; } - graphKit.fillArgsArray(argumentArray, receiverOffset, args, argTypes); + kit.fillArgsArray(argumentArray, receiverOffset, args, argTypes); for (int i = 0; i < argTypes.length; i++) { - signature[i + receiverOffset] = providers.getMetaAccess().lookupJavaType(argTypes[i]); + signature[i + receiverOffset] = kit.getMetaAccess().lookupJavaType(argTypes[i]); } - CallTargetNode callTarget = graphKit.append(new IndirectCallTargetNode(invokedMethod, args, StampPair.createSingle(StampFactory.forKind(returnKind)), signature, null, + CallTargetNode callTarget = kit.append(new IndirectCallTargetNode(invokedMethod, args, StampPair.createSingle(StampFactory.forKind(returnKind)), signature, null, SubstrateCallingConventionKind.Java.toType(true), InvokeKind.Static)); - InvokeWithExceptionNode invoke = graphKit.startInvokeWithException(callTarget, graphKit.getFrameState(), graphKit.bci()); - graphKit.exceptionPart(); - graphKit.branchToInvocationTargetException(graphKit.exceptionObject()); - graphKit.endInvokeWithException(); + InvokeWithExceptionNode invoke = kit.startInvokeWithException(callTarget, kit.getFrameState(), kit.bci()); + kit.exceptionPart(); + kit.branchToInvocationTargetException(kit.exceptionObject()); + kit.endInvokeWithException(); ValueNode returnValue; if (returnKind == JavaKind.Void) { - returnValue = graphKit.createObject(null); + returnValue = kit.createObject(null); } else { returnValue = invoke; if (returnKind.isPrimitive()) { - ResolvedJavaType boxedRetType = graphKit.getMetaAccess().lookupJavaType(returnKind.toBoxedJavaClass()); - returnValue = graphKit.createBoxing(returnValue, returnKind, boxedRetType); + AnalysisType boxedRetType = kit.getMetaAccess().lookupJavaType(returnKind.toBoxedJavaClass()); + returnValue = kit.createBoxing(returnValue, returnKind, boxedRetType); } } - graphKit.createReturn(returnValue, JavaKind.Object); + kit.createReturn(returnValue, JavaKind.Object); - graphKit.emitIllegalArgumentException(isStatic ? null : receiver, argumentArray); - graphKit.emitInvocationTargetException(); + kit.emitIllegalArgumentException(isStatic ? null : receiver, argumentArray); + kit.emitInvocationTargetException(); - return graphKit.finalizeGraph(); + return kit.finalizeGraph(); } } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionMetadataEncoderImpl.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionMetadataEncoderImpl.java index e4ce764a378a..91366490cf79 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionMetadataEncoderImpl.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionMetadataEncoderImpl.java @@ -403,7 +403,7 @@ public void addReflectionExecutableMetadata(MetaAccessProvider metaAccess, Hoste HostedType[] parameterTypes = getParameterTypes(hostedMethod); /* Reflect method because substitution of Object.hashCode() is private */ int modifiers = reflectMethod.getModifiers(); - HostedType returnType = (HostedType) hostedMethod.getSignature().getReturnType(null); + HostedType returnType = hostedMethod.getSignature().getReturnType(); HostedType[] exceptionTypes = getExceptionTypes(metaAccess, reflectMethod); String signature = getSignature(reflectMethod); @@ -636,7 +636,7 @@ public void addNegativeConstructorQueryMetadata(HostedType declaringClass, Hoste private static HostedType[] getParameterTypes(HostedMethod method) { HostedType[] parameterTypes = new HostedType[method.getSignature().getParameterCount(false)]; for (int i = 0; i < parameterTypes.length; ++i) { - parameterTypes[i] = (HostedType) method.getSignature().getParameterType(i, null); + parameterTypes[i] = method.getSignature().getParameterType(i); } return parameterTypes; } @@ -644,7 +644,7 @@ private static HostedType[] getParameterTypes(HostedMethod method) { private static String[] getParameterTypeNames(HostedMethod method) { String[] parameterTypeNames = new String[method.getSignature().getParameterCount(false)]; for (int i = 0; i < parameterTypeNames.length; ++i) { - parameterTypeNames[i] = method.getSignature().getParameterType(i, null).toJavaName(); + parameterTypeNames[i] = method.getSignature().getParameterType(i).toJavaName(); } return parameterTypeNames; } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/AnnotatedMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/AnnotatedMethod.java index d7b03ca04a42..b6fa64198f48 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/AnnotatedMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/AnnotatedMethod.java @@ -30,18 +30,19 @@ import java.lang.reflect.Type; import java.util.Arrays; -import jdk.graal.compiler.debug.DebugContext; -import jdk.graal.compiler.nodes.StructuredGraph; import org.graalvm.nativeimage.AnnotationAccess; import com.oracle.graal.pointsto.infrastructure.GraphProvider; import com.oracle.graal.pointsto.infrastructure.OriginalMethodProvider; +import com.oracle.graal.pointsto.meta.AnalysisMethod; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.core.util.VMError; import com.oracle.svm.hosted.annotation.AnnotationValue; import com.oracle.svm.hosted.annotation.AnnotationWrapper; import com.oracle.svm.hosted.annotation.SubstrateAnnotationExtractor; +import jdk.graal.compiler.debug.DebugContext; +import jdk.graal.compiler.nodes.StructuredGraph; import jdk.vm.ci.meta.Constant; import jdk.vm.ci.meta.ConstantPool; import jdk.vm.ci.meta.ExceptionHandler; @@ -84,17 +85,17 @@ public Signature getSignature() { } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { - if (original instanceof GraphProvider) { - return ((GraphProvider) original).buildGraph(debug, method, providers, purpose); + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { + if (original instanceof GraphProvider graphProvider) { + return graphProvider.buildGraph(debug, method, providers, purpose); } return null; } @Override public boolean allowRuntimeCompilation() { - if (original instanceof GraphProvider) { - return ((GraphProvider) original).allowRuntimeCompilation(); + if (original instanceof GraphProvider graphProvider) { + return graphProvider.allowRuntimeCompilation(); } return true; } diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/DeletedMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/DeletedMethod.java index 3f079b169e83..8c698dacf7b2 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/DeletedMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/DeletedMethod.java @@ -27,6 +27,7 @@ import java.lang.reflect.Method; import java.lang.reflect.Modifier; +import com.oracle.graal.pointsto.meta.AnalysisMethod; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.core.annotate.Delete; import com.oracle.svm.core.option.SubstrateOptionsParser; @@ -38,7 +39,6 @@ import com.oracle.svm.util.ReflectionUtil; import jdk.graal.compiler.debug.DebugContext; -import jdk.graal.compiler.java.FrameStateBuilder; import jdk.graal.compiler.nodes.CallTargetNode.InvokeKind; import jdk.graal.compiler.nodes.ConstantNode; import jdk.graal.compiler.nodes.StructuredGraph; @@ -78,26 +78,18 @@ public int getModifiers() { } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { - return buildGraph(debug, method, providers, message, purpose); + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { + return buildGraph(debug, method, providers, message); } - public static StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, String message, Purpose purpose) { + public static StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, String message) { HostedGraphKit kit = new HostedGraphKit(debug, providers, method); - StructuredGraph graph = kit.getGraph(); - FrameStateBuilder state = new FrameStateBuilder(null, method, graph); - state.initializeForMethodStart(null, true, providers.getGraphBuilderPlugins()); - /* - * A random, but unique and consistent, number for every invoke. This is necessary because - * we, e.g., look up static analysis results by bci. - */ - int bci = 0; - graph.start().setStateAfter(state.create(bci++, graph.start())); + kit.getGraph().start().setStateAfter(kit.getFrameState().create(kit.bci(), kit.getGraph().start())); String msg = AnnotationSubstitutionProcessor.deleteErrorMessage(method, message, false); - ValueNode msgNode = ConstantNode.forConstant(providers.getConstantReflection().forString(msg), providers.getMetaAccess(), graph); - ValueNode exceptionNode = kit.createInvokeWithExceptionAndUnwind(providers.getMetaAccess().lookupJavaMethod(reportErrorMethod), InvokeKind.Static, state, bci++, msgNode); + ValueNode msgNode = ConstantNode.forConstant(kit.getConstantReflection().forString(msg), kit.getMetaAccess(), kit.getGraph()); + ValueNode exceptionNode = kit.createInvokeWithExceptionAndUnwind(kit.getMetaAccess().lookupJavaMethod(reportErrorMethod), InvokeKind.Static, kit.getFrameState(), kit.bci(), msgNode); kit.append(new UnwindNode(exceptionNode)); return kit.finalizeGraph(); diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/PolymorphicSignatureWrapperMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/PolymorphicSignatureWrapperMethod.java index 0a433748e3eb..3dd291cd1be9 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/PolymorphicSignatureWrapperMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/PolymorphicSignatureWrapperMethod.java @@ -31,10 +31,11 @@ import java.lang.invoke.MethodHandle; import java.lang.reflect.AnnotatedElement; import java.lang.reflect.Type; +import java.util.ArrayList; import java.util.List; import com.oracle.graal.pointsto.infrastructure.GraphProvider; -import com.oracle.graal.pointsto.meta.AnalysisMetaAccess; +import com.oracle.graal.pointsto.meta.AnalysisMethod; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.core.invoke.MethodHandleUtils; import com.oracle.svm.core.invoke.Target_java_lang_invoke_MemberName; @@ -82,28 +83,27 @@ public class PolymorphicSignatureWrapperMethod implements ResolvedJavaMethod, Gr } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { - AnalysisMetaAccess metaAccess = (AnalysisMetaAccess) providers.getMetaAccess(); + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { HostedGraphKit kit = new HostedGraphKit(debug, providers, method); - List args = kit.loadArguments(method.toParameterTypes()); + List args = new ArrayList<>(kit.getInitialArguments()); ValueNode receiver = null; if (!substitutionBaseMethod.isStatic()) { receiver = args.remove(0); } - ValueNode parameterArray = kit.append(new NewArrayNode(metaAccess.lookupJavaType(Object.class), kit.createInt(args.size()), true)); + ValueNode parameterArray = kit.append(new NewArrayNode(kit.getMetaAccess().lookupJavaType(Object.class), kit.createInt(args.size()), true)); for (int i = 0; i < args.size(); ++i) { ValueNode arg = args.get(i); if (arg.getStackKind().isPrimitive()) { - arg = kit.createBoxing(arg, arg.getStackKind(), metaAccess.lookupJavaType(arg.getStackKind().toBoxedJavaClass())); + arg = kit.createBoxing(arg, arg.getStackKind(), kit.getMetaAccess().lookupJavaType(arg.getStackKind().toBoxedJavaClass())); } StateSplit storeIndexedNode = (StateSplit) kit.createStoreIndexed(parameterArray, i, JavaKind.Object, arg); storeIndexedNode.setStateAfter(kit.getFrameState().create(kit.bci(), storeIndexedNode)); } - ResolvedJavaMethod invokeTarget = metaAccess.getUniverse().lookup(substitutionBaseMethod.getOriginal()); + AnalysisMethod invokeTarget = kit.getMetaAccess().getUniverse().lookup(substitutionBaseMethod.getOriginal()); InvokeWithExceptionNode invoke; if (substitutionBaseMethod.isStatic()) { invoke = kit.createInvokeWithExceptionAndUnwind(invokeTarget, CallTargetNode.InvokeKind.Static, kit.getFrameState(), kit.bci(), parameterArray); @@ -141,7 +141,7 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, case Int: case Long: ValueNode methodHandleOrMemberName; - ResolvedJavaMethod unboxMethod; + AnalysisMethod unboxMethod; try { String unboxMethodName = returnKind.toString() + "Unbox"; switch (substitutionBaseMethod.getName()) { @@ -149,7 +149,7 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, case "invokeExact": case "invoke": methodHandleOrMemberName = receiver; - unboxMethod = metaAccess.lookupJavaMethod( + unboxMethod = kit.getMetaAccess().lookupJavaMethod( MethodHandleUtils.class.getMethod(unboxMethodName, Object.class, MethodHandle.class)); break; case "linkToVirtual": @@ -157,7 +157,7 @@ public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, case "linkToInterface": case "linkToSpecial": methodHandleOrMemberName = args.get(args.size() - 1); - unboxMethod = metaAccess.lookupJavaMethod( + unboxMethod = kit.getMetaAccess().lookupJavaMethod( MethodHandleUtils.class.getMethod(unboxMethodName, Object.class, Target_java_lang_invoke_MemberName.class)); break; default: diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionMethod.java index 3a41c9d2a0f8..aec7d8df4c1b 100644 --- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionMethod.java +++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionMethod.java @@ -32,14 +32,14 @@ import java.lang.reflect.Executable; import java.lang.reflect.Type; -import jdk.graal.compiler.debug.DebugContext; -import jdk.graal.compiler.nodes.StructuredGraph; - import com.oracle.graal.pointsto.infrastructure.GraphProvider; import com.oracle.graal.pointsto.infrastructure.OriginalMethodProvider; +import com.oracle.graal.pointsto.meta.AnalysisMethod; import com.oracle.graal.pointsto.meta.HostedProviders; import com.oracle.svm.hosted.annotation.AnnotationWrapper; +import jdk.graal.compiler.debug.DebugContext; +import jdk.graal.compiler.nodes.StructuredGraph; import jdk.vm.ci.meta.Constant; import jdk.vm.ci.meta.ConstantPool; import jdk.vm.ci.meta.ExceptionHandler; @@ -113,17 +113,17 @@ public Signature getSignature() { } @Override - public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { - if (annotated instanceof GraphProvider) { - return ((GraphProvider) annotated).buildGraph(debug, method, providers, purpose); + public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) { + if (annotated instanceof GraphProvider graphProvider) { + return graphProvider.buildGraph(debug, method, providers, purpose); } return null; } @Override public boolean allowRuntimeCompilation() { - if (annotated instanceof GraphProvider) { - return ((GraphProvider) annotated).allowRuntimeCompilation(); + if (annotated instanceof GraphProvider graphProvider) { + return graphProvider.allowRuntimeCompilation(); } return true; }