[GR-39848] Do not use method and field annotations during JIT compilation.

PullRequest: graal/14106

Author: Christian Wimmer

compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/StructuredGraph.java

@@ -24,9 +24,6 @@
  */
 package org.graalvm.compiler.nodes;
 
-import static jdk.vm.ci.services.Services.IS_BUILDING_NATIVE_IMAGE;
-import static jdk.vm.ci.services.Services.IS_IN_NATIVE_IMAGE;
-
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Iterator;
@@ -336,26 +333,12 @@ private StructuredGraph(String name,
         assert !isSubstitution || profileProvider == null;
         this.profileProvider = profileProvider;
         this.isSubstitution = isSubstitution;
-        assert checkIsSubstitutionInvariants(method, isSubstitution);
         this.cancellable = cancellable;
         this.inliningLog = GraalOptions.TraceInlining.getValue(options) || OptimizationLog.isOptimizationLogEnabled(options) ? new InliningLog(rootMethod) : null;
         this.callerContext = context;
         this.optimizationLog = OptimizationLog.getInstance(this);
     }
 
-    private static boolean checkIsSubstitutionInvariants(ResolvedJavaMethod method, boolean isSubstitution) {
-        if (!IS_IN_NATIVE_IMAGE && !IS_BUILDING_NATIVE_IMAGE) {
-            if (method != null) {
-                if (method.getAnnotation(Snippet.class) != null) {
-                    assert isSubstitution : "Graph for method " + method.format("%H.%n(%p)") +
-                                    " annotated by " + Snippet.class.getName() +
-                                    " must have its `isSubstitution` field set to true";
-                }
-            }
-        }
-        return true;
-    }
-
     public void setLastSchedule(ScheduleResult result) {
         GraalError.guarantee(result == null || result.cfg.getStartBlock().isModifiable(), "Schedule must use blocks that can be modified");
         lastSchedule = result;

compiler/src/org.graalvm.compiler.truffle.common/src/org/graalvm/compiler/truffle/common/TruffleCompilerRuntime.java

@@ -98,6 +98,19 @@ public static ConstantFieldInfo forDimensions(int dimensions) {
         private ConstantFieldInfo(int dimensions) {
             this.dimensions = dimensions;
         }
+
+        @Override
+        public int hashCode() {
+            return dimensions;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj instanceof ConstantFieldInfo other) {
+                return dimensions == other.dimensions;
+            }
+            return false;
+        }
     }
 
     /**

compiler/src/org.graalvm.compiler.truffle.runtime/src/org/graalvm/compiler/truffle/runtime/GraalTruffleRuntime.java

@@ -948,9 +948,6 @@ public final class KnownMethods {
         public final ResolvedJavaMethod callTargetMethod;
         public final ResolvedJavaMethod callInlinedCallMethod;
         public final ResolvedJavaMethod[] anyFrameMethod;
-        public final ResolvedJavaMethod inInterpreterMethod;
-        public final ResolvedJavaMethod inInterpreterFastPathMethod;
-        public final ResolvedJavaMethod[] transferToInterpreterMethods;
 
         public KnownMethods(MetaAccessProvider metaAccess) {
             this.callDirectMethod = metaAccess.lookupJavaMethod(GraalFrameInstance.CALL_DIRECT);
@@ -959,26 +956,9 @@ public KnownMethods(MetaAccessProvider metaAccess) {
             this.callInlinedCallMethod = metaAccess.lookupJavaMethod(GraalFrameInstance.CALL_INLINED_CALL);
             this.callTargetMethod = metaAccess.lookupJavaMethod(GraalFrameInstance.CALL_TARGET_METHOD);
             this.anyFrameMethod = new ResolvedJavaMethod[]{callDirectMethod, callIndirectMethod, callInlinedMethod, callTargetMethod, callInlinedCallMethod};
-            ResolvedJavaType compilerDirectives = metaAccess.lookupJavaType(CompilerDirectives.class);
-            this.transferToInterpreterMethods = new ResolvedJavaMethod[2];
-            this.transferToInterpreterMethods[0] = searchMethod(compilerDirectives, "transferToInterpreter");
-            this.transferToInterpreterMethods[1] = searchMethod(compilerDirectives, "transferToInterpreterAndInvalidate");
-            this.inInterpreterMethod = searchMethod(compilerDirectives, "inInterpreter");
-
-            ResolvedJavaType hostCompilerDirectives = metaAccess.lookupJavaType(HostCompilerDirectives.class);
-            this.inInterpreterFastPathMethod = searchMethod(hostCompilerDirectives, "inInterpreterFastPath");
         }
     }
 
-    protected static ResolvedJavaMethod searchMethod(ResolvedJavaType type, String name) {
-        for (ResolvedJavaMethod searchMethod : type.getDeclaredMethods()) {
-            if (searchMethod.getName().equals(name)) {
-                return searchMethod;
-            }
-        }
-        throw CompilerDirectives.shouldNotReachHere(type + "." + name + " method not found.");
-    }
-
     @Override
     public boolean isValueType(ResolvedJavaType type) {
         return getAnnotation(CompilerDirectives.ValueType.class, type) != null;
@@ -1042,30 +1022,25 @@ public boolean isInliningCutoff(ResolvedJavaMethod method) {
      * Determines if {@code method} is an inInterpeter method.
      */
     @Override
-    public boolean isInInterpreter(ResolvedJavaMethod targetMethod) {
-        return getKnownMethods().inInterpreterMethod.equals(targetMethod);
+    public boolean isInInterpreter(ResolvedJavaMethod method) {
+        return method.getName().equals("inInterpreter") && method.getDeclaringClass().toClassName().equals(CompilerDirectives.class.getName());
     }
 
     /**
      * Determines if {@code method} is an inInterpeter method.
      */
     @Override
-    public boolean isInInterpreterFastPath(ResolvedJavaMethod targetMethod) {
-        return getKnownMethods().inInterpreterFastPathMethod.equals(targetMethod);
+    public boolean isInInterpreterFastPath(ResolvedJavaMethod method) {
+        return method.getName().equals("inInterpreterFastPath") && method.getDeclaringClass().toClassName().equals(HostCompilerDirectives.class.getName());
     }
 
     /**
      * Determines if {@code method} is a method is a transferToInterpreter method.
      */
     @Override
     public boolean isTransferToInterpreterMethod(ResolvedJavaMethod method) {
-        ResolvedJavaMethod[] methods = getKnownMethods().transferToInterpreterMethods;
-        for (int i = 0; i < methods.length; i++) {
-            if (methods[i].equals(method)) {
-                return true;
-            }
-        }
-        return false;
+        return (method.getName().equals("transferToInterpreter") || method.getName().equals("transferToInterpreterAndInvalidate")) &&
+                        method.getDeclaringClass().toClassName().equals(CompilerDirectives.class.getName());
     }
 
     @SuppressWarnings("deprecation")

substratevm/src/com.oracle.svm.core.graal.aarch64/src/com/oracle/svm/core/graal/aarch64/SubstrateAArch64Backend.java

@@ -117,7 +117,6 @@
 import org.graalvm.compiler.phases.BasePhase;
 import org.graalvm.compiler.phases.common.AddressLoweringByUsePhase;
 import org.graalvm.compiler.phases.util.Providers;
-import org.graalvm.nativeimage.AnnotationAccess;
 import org.graalvm.nativeimage.ImageSingletons;
 
 import com.oracle.svm.core.FrameAccess;
@@ -152,7 +151,6 @@
 import com.oracle.svm.core.meta.SubstrateMethodPointerConstant;
 import com.oracle.svm.core.meta.SubstrateObjectConstant;
 import com.oracle.svm.core.nodes.SafepointCheckNode;
-import com.oracle.svm.core.snippets.SubstrateForeignCallTarget;
 import com.oracle.svm.core.thread.VMThreads.StatusSupport;
 import com.oracle.svm.core.util.VMError;
 
@@ -791,8 +789,8 @@ public Variable emitReadReturnAddress() {
 
         @Override
         public ForeignCallLinkage lookupGraalStub(ValueNode valueNode, ForeignCallDescriptor foreignCallDescriptor) {
-            ResolvedJavaMethod method = valueNode.graph().method();
-            if (method != null && AnnotationAccess.getAnnotation(method, SubstrateForeignCallTarget.class) != null) {
+            SharedMethod method = (SharedMethod) valueNode.graph().method();
+            if (method != null && method.isForeignCallTarget()) {
                 // Emit assembly for snippet stubs
                 return null;
             }

substratevm/src/com.oracle.svm.core.graal.amd64/src/com/oracle/svm/core/graal/amd64/SubstrateAMD64Backend.java

@@ -126,7 +126,6 @@
 import org.graalvm.compiler.phases.common.AddressLoweringByNodePhase;
 import org.graalvm.compiler.phases.util.Providers;
 import org.graalvm.compiler.replacements.amd64.AMD64IntrinsicStubs;
-import org.graalvm.nativeimage.AnnotationAccess;
 import org.graalvm.nativeimage.ImageSingletons;
 
 import com.oracle.svm.core.CPUFeatureAccess;
@@ -169,7 +168,6 @@
 import com.oracle.svm.core.meta.SubstrateMethodPointerConstant;
 import com.oracle.svm.core.meta.SubstrateObjectConstant;
 import com.oracle.svm.core.nodes.SafepointCheckNode;
-import com.oracle.svm.core.snippets.SubstrateForeignCallTarget;
 import com.oracle.svm.core.thread.VMThreads.StatusSupport;
 import com.oracle.svm.core.util.VMError;
 
@@ -926,8 +924,8 @@ public Variable emitReadReturnAddress() {
 
         @Override
         public ForeignCallLinkage lookupGraalStub(ValueNode valueNode, ForeignCallDescriptor foreignCallDescriptor) {
-            ResolvedJavaMethod method = valueNode.graph().method();
-            if (method != null && AnnotationAccess.getAnnotation(method, SubstrateForeignCallTarget.class) != null) {
+            SharedMethod method = (SharedMethod) valueNode.graph().method();
+            if (method != null && method.isForeignCallTarget()) {
                 // Emit assembly for snippet stubs
                 return null;
             }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/Uninterruptible.java

@@ -34,6 +34,8 @@
 
 import org.graalvm.compiler.api.replacements.Fold;
 import org.graalvm.nativeimage.AnnotationAccess;
+import org.graalvm.nativeimage.Platform;
+import org.graalvm.nativeimage.Platforms;
 import org.graalvm.nativeimage.c.function.CFunction;
 import org.graalvm.nativeimage.c.function.InvokeCFunctionPointer;
 import org.graalvm.word.WordBase;
@@ -202,10 +204,12 @@ public static Uninterruptible getAnnotation(AnnotatedElement method) {
          * Returns whether the method is {@link Uninterruptible}, either by explicit annotation of
          * the method or implicitly due to other annotations.
          */
+        @Platforms(Platform.HOSTED_ONLY.class)
         public static boolean isUninterruptible(AnnotatedElement method) {
             return getAnnotation(method) != null;
         }
 
+        @Platforms(Platform.HOSTED_ONLY.class)
         public static boolean inliningAllowed(AnnotatedElement caller, AnnotatedElement callee) {
             boolean callerUninterruptible = isUninterruptible(caller);
             boolean calleeUninterruptible = isUninterruptible(callee);

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/code/ExplicitCallingConvention.java

@@ -29,11 +29,31 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import org.graalvm.nativeimage.AnnotationAccess;
+import org.graalvm.nativeimage.Platform;
+import org.graalvm.nativeimage.Platforms;
+
+import jdk.vm.ci.meta.ResolvedJavaMethod;
+
 /**
  * Annotation that overrides the default calling convention used for a method.
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(value = {ElementType.METHOD})
 public @interface ExplicitCallingConvention {
     SubstrateCallingConventionKind value();
+
+    class Util {
+        @Platforms(Platform.HOSTED_ONLY.class)
+        public static SubstrateCallingConventionKind getCallingConventionKind(ResolvedJavaMethod method, boolean isEntryPoint) {
+            ExplicitCallingConvention explicitCallingConvention = AnnotationAccess.getAnnotation(method, ExplicitCallingConvention.class);
+            if (explicitCallingConvention != null) {
+                return explicitCallingConvention.value();
+            } else if (isEntryPoint) {
+                return SubstrateCallingConventionKind.Native;
+            } else {
+                return SubstrateCallingConventionKind.Java;
+            }
+        }
+    }
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/code/StubCallingConvention.java

@@ -51,6 +51,7 @@
 public @interface StubCallingConvention {
 
     class Utils {
+        @Platforms(Platform.HOSTED_ONLY.class)
         public static boolean hasStubCallingConvention(ResolvedJavaMethod method) {
             boolean result = false;
             if (CalleeSavedRegisters.supportedByPlatform()) {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/code/SubstrateMetaAccessExtensionProvider.java

@@ -27,7 +27,6 @@
 
 import org.graalvm.compiler.core.common.spi.MetaAccessExtensionProvider;
 
-import com.oracle.svm.core.Uninterruptible;
 import com.oracle.svm.core.meta.SharedMethod;
 import com.oracle.svm.core.meta.SharedType;
 
@@ -59,14 +58,14 @@ public boolean isGuaranteedSafepoint(ResolvedJavaMethod method, boolean isDirect
 
         // check if the method itself indicates it will not have a safepoint.
         SharedMethod sharedMethod = (SharedMethod) method;
-        if (Uninterruptible.Utils.isUninterruptible(sharedMethod)) {
+        if (sharedMethod.isUninterruptible()) {
             return false;
         }
 
         // for indirect calls, confirming all implementations also have safepoints.
         if (!isDirect) {
             for (SharedMethod implementation : sharedMethod.getImplementations()) {
-                if (Uninterruptible.Utils.isUninterruptible(implementation)) {
+                if (implementation.isUninterruptible()) {
                     return false;
                 }
             }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/meta/SubstrateReplacements.java

@@ -87,6 +87,7 @@
 
 import com.oracle.svm.core.SubstrateTargetDescription;
 import com.oracle.svm.core.config.ConfigurationValues;
+import com.oracle.svm.core.meta.SharedMethod;
 import com.oracle.svm.core.option.HostedOptionValues;
 import com.oracle.svm.core.util.VMError;
 
@@ -407,4 +408,13 @@ public Stamp getInjectedStamp(Class<?> type, boolean nonNull) {
             return StampFactory.forKind(kind);
         }
     }
+
+    @Override
+    public boolean isSnippet(ResolvedJavaMethod method) {
+        if (method instanceof SharedMethod sharedMethod) {
+            return sharedMethod.isSnippet();
+        } else {
+            return super.isSnippet(method);
+        }
+    }
 }