Avoid the use of HotSpot JVMCI types to detect host vm objects

Instead detect native image build-time elements using:
* OriginalFieldClassProvider for fields
* OriginalMethodProvider for methods
* OriginalClassProvider for types
* ResolvedSignature for signatures
* ImageHeapConstant to object constants
And SVM runtime elements using:
* SubstrateField for fields
* SharedRuntimeMethod for methods
* SubstrateType for types
* SubstrateSignature for signatures
* SubstrateObjectConstant for object constants

Use "host VM" instead "HotSpot" in some comments.

Author: gilles-duboscq

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/TruffleDebugJavaMethod.java

@@ -24,6 +24,8 @@
  */
 package jdk.graal.compiler.truffle;
 
+import java.util.Objects;
+
 import com.oracle.truffle.compiler.TruffleCompilable;
 import com.oracle.truffle.compiler.TruffleCompilationTask;
 
@@ -51,27 +53,44 @@ public final class TruffleDebugJavaMethod implements JavaMethod {
         }
     }
 
-    private static class TruffleJavaType implements JavaType {
+    public static final class TruffleSignature implements Signature {
+        private final TruffleJavaType returnType;
 
-        private final String name;
+        public TruffleSignature(TruffleJavaType returnType) {
+            this.returnType = returnType;
+        }
 
-        final Signature signature = new Signature() {
+        @Override
+        public JavaType getReturnType(ResolvedJavaType accessingClass) {
+            return returnType;
+        }
 
-            @Override
-            public JavaType getReturnType(ResolvedJavaType accessingClass) {
-                return TruffleJavaType.this;
-            }
+        @Override
+        public int getParameterCount(boolean receiver) {
+            return 0;
+        }
 
-            @Override
-            public int getParameterCount(boolean receiver) {
-                return 0;
-            }
+        @Override
+        public JavaType getParameterType(int index, ResolvedJavaType accessingClass) {
+            throw new IndexOutOfBoundsException();
+        }
 
-            @Override
-            public JavaType getParameterType(int index, ResolvedJavaType accessingClass) {
-                throw new IndexOutOfBoundsException();
+        @Override
+        public boolean equals(Object obj) {
+            if (!(obj instanceof TruffleSignature truffleSignature)) {
+                return false;
             }
-        };
+            return returnType.equals(truffleSignature.returnType);
+        }
+
+        @Override
+        public int hashCode() {
+            return returnType.hashCode();
+        }
+    }
+
+    public static final class TruffleJavaType implements JavaType {
+        private final String name;
 
         TruffleJavaType(int tier) {
             this.name = "LTruffleIR/Tier" + tier + ";";
@@ -141,12 +160,12 @@ public int hashCode() {
 
     @Override
     public Signature getSignature() {
-        return TIERS[task.tier()].signature;
+        return new TruffleSignature(TIERS[task.tier()]);
     }
 
     @Override
     public String getName() {
-        return (compilable.getName() + "").replace('.', '_').replace(' ', '_');
+        return Objects.toString(compilable.getName()).replace('.', '_').replace(' ', '_');
     }
 
     @Override

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/heap/ImageHeapScanner.java

@@ -417,7 +417,7 @@ private Optional<JavaConstant> maybeReplace(JavaConstant constant, ScanReason re
                 /* Enhance the unsupported feature message with the object trace and rethrow. */
                 StringBuilder backtrace = new StringBuilder();
                 ObjectScanner.buildObjectBacktrace(bb, reason, backtrace);
-                throw new UnsupportedFeatureException(e.getMessage() + System.lineSeparator() + backtrace);
+                throw new UnsupportedFeatureException(e.getMessage() + System.lineSeparator() + backtrace, e);
             }
 
         }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/meta/CompressedNullConstant.java

@@ -25,7 +25,6 @@
 package com.oracle.svm.core.meta;
 
 import jdk.graal.compiler.core.common.type.CompressibleConstant;
-
 import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.JavaKind;
 

substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/SubstrateGraalUtils.java

@@ -31,7 +31,6 @@
 import java.util.EnumMap;
 import java.util.Map;
 
-import jdk.graal.compiler.phases.util.Providers;
 import org.graalvm.collections.EconomicMap;
 import org.graalvm.nativeimage.ImageSingletons;
 
@@ -70,8 +69,8 @@
 import jdk.graal.compiler.options.OptionValues;
 import jdk.graal.compiler.phases.OptimisticOptimizations;
 import jdk.graal.compiler.phases.tiers.Suites;
+import jdk.graal.compiler.phases.util.Providers;
 import jdk.vm.ci.code.Architecture;
-import jdk.vm.ci.hotspot.HotSpotObjectConstant;
 import jdk.vm.ci.meta.ConstantReflectionProvider;
 import jdk.vm.ci.meta.JavaConstant;
 
@@ -232,22 +231,23 @@ public static JavaConstant hostedToRuntime(JavaConstant constant, ConstantReflec
     }
 
     /**
-     * Prepares a hosted {@link ImageHeapConstant} for runtime compilation: it unwraps the
-     * {@link HotSpotObjectConstant} and wraps the hosted object into a
-     * {@link SubstrateObjectConstant}. We reuse the identity hash code of the heap constant.
+     * Prepares a hosted {@link ImageHeapConstant} for runtime compilation: it unwraps the host
+     * {@link JavaConstant} and wraps the hosted object into a {@link SubstrateObjectConstant}. We
+     * reuse the identity hash code of the heap constant.
      */
     public static JavaConstant hostedToRuntime(ImageHeapConstant heapConstant, ConstantReflectionProvider constantReflection) {
         JavaConstant hostedConstant = heapConstant.getHostedObject();
-        VMError.guarantee(hostedConstant instanceof HotSpotObjectConstant, "Expected to find HotSpotObjectConstant, found %s", hostedConstant);
+        VMError.guarantee(hostedConstant.getJavaKind().isObject() && !hostedConstant.isDefaultForKind() && !(hostedConstant instanceof ImageHeapConstant),
+                        "Expected to find host object JavaConstant, found %s", hostedConstant);
         Object hostedObject = GraalAccess.getOriginalSnippetReflection().asObject(Object.class, hostedConstant);
         return SubstrateObjectConstant.forObject(hostedObject, ((IdentityHashCodeProvider) constantReflection).identityHashCode(heapConstant));
     }
 
     /**
      * Transforms a {@link SubstrateObjectConstant} from an encoded graph into an
      * {@link ImageHeapConstant} for hosted processing: it unwraps the hosted object from the
-     * {@link SubstrateObjectConstant}, wraps it into an {@link HotSpotObjectConstant}, then
-     * redirects the lookup through the {@link ImageHeapScanner}.
+     * {@link SubstrateObjectConstant}, wraps it into a host {@link JavaConstant}, then redirects
+     * the lookup through the {@link ImageHeapScanner}.
      */
     public static JavaConstant runtimeToHosted(JavaConstant constant, ImageHeapScanner scanner) {
         if (constant instanceof SubstrateObjectConstant) {

substratevm/src/com.oracle.svm.graal/src/com/oracle/svm/graal/hosted/runtimecompilation/GraalGraphObjectReplacer.java

@@ -34,6 +34,9 @@
 
 import com.oracle.graal.pointsto.constraints.UnsupportedFeatureException;
 import com.oracle.graal.pointsto.heap.ImageHeapConstant;
+import com.oracle.graal.pointsto.infrastructure.OriginalClassProvider;
+import com.oracle.graal.pointsto.infrastructure.OriginalFieldProvider;
+import com.oracle.graal.pointsto.infrastructure.OriginalMethodProvider;
 import com.oracle.graal.pointsto.infrastructure.ResolvedSignature;
 import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
@@ -42,8 +45,10 @@
 import com.oracle.svm.common.meta.MultiMethod;
 import com.oracle.svm.core.code.CodeInfoTable;
 import com.oracle.svm.core.code.ImageCodeInfo;
+import com.oracle.svm.core.graal.meta.SharedRuntimeMethod;
 import com.oracle.svm.core.graal.nodes.SubstrateFieldLocationIdentity;
 import com.oracle.svm.core.hub.DynamicHub;
+import com.oracle.svm.core.meta.SubstrateObjectConstant;
 import com.oracle.svm.core.option.HostedOptionKey;
 import com.oracle.svm.core.util.HostedStringDeduplication;
 import com.oracle.svm.core.util.ObservableImageHeapMapProvider;
@@ -76,22 +81,21 @@
 import jdk.graal.compiler.hotspot.HotSpotBackendFactory;
 import jdk.graal.compiler.hotspot.SnippetResolvedJavaMethod;
 import jdk.graal.compiler.hotspot.SnippetResolvedJavaType;
+import jdk.graal.compiler.hotspot.SnippetSignature;
 import jdk.graal.compiler.nodes.FieldLocationIdentity;
 import jdk.graal.compiler.options.Option;
 import jdk.graal.compiler.phases.util.Providers;
+import jdk.graal.compiler.truffle.TruffleDebugJavaMethod;
 import jdk.vm.ci.code.Architecture;
 import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime;
-import jdk.vm.ci.hotspot.HotSpotObjectConstant;
-import jdk.vm.ci.hotspot.HotSpotResolvedJavaField;
-import jdk.vm.ci.hotspot.HotSpotResolvedJavaMethod;
-import jdk.vm.ci.hotspot.HotSpotResolvedJavaType;
-import jdk.vm.ci.hotspot.HotSpotSignature;
 import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.JavaType;
 import jdk.vm.ci.meta.MetaAccessProvider;
 import jdk.vm.ci.meta.ResolvedJavaField;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
+import jdk.vm.ci.meta.Signature;
+import jdk.vm.ci.runtime.JVMCIRuntime;
 
 /**
  * Replaces Graal related objects during analysis in the universe.
@@ -142,6 +146,7 @@ public void setAnalysisAccess(BeforeAnalysisAccessImpl beforeAnalysisAccess) {
         this.beforeAnalysisAccess = beforeAnalysisAccess;
     }
 
+    @SuppressWarnings("unchecked")
     @Override
     public Object apply(Object source) {
 
@@ -155,13 +160,14 @@ public Object apply(Object source) {
             return dest;
         }
 
-        if (source instanceof SnippetResolvedJavaMethod || source instanceof SnippetResolvedJavaType) {
+        if (source instanceof SnippetResolvedJavaMethod || source instanceof SnippetResolvedJavaType || source instanceof SnippetSignature) {
+            // skip checks for "hotspot" in the class name
             return source;
         }
         if (source instanceof MetaAccessProvider) {
             dest = sProviders.getMetaAccessProvider();
-        } else if (source instanceof HotSpotJVMCIRuntime) {
-            throw new UnsupportedFeatureException("HotSpotJVMCIRuntime should not appear in the image: " + source);
+        } else if (source instanceof JVMCIRuntime) {
+            throw new UnsupportedFeatureException("JVMCIRuntime should not appear in the image: " + source);
         } else if (source instanceof GraalHotSpotVMConfig) {
             throw new UnsupportedFeatureException("GraalHotSpotVMConfig should not appear in the image: " + source);
         } else if (source instanceof HotSpotBackendFactory) {
@@ -188,26 +194,38 @@ public Object apply(Object source) {
             /* Ensure lazily initialized shortName field is computed. */
             ((NodeClass<?>) source).shortName();
 
-        } else if (source instanceof HotSpotResolvedJavaMethod) {
-            throw new UnsupportedFeatureException(source.toString());
-        } else if (source instanceof HotSpotResolvedJavaField) {
-            throw new UnsupportedFeatureException(source.toString());
-        } else if (source instanceof HotSpotResolvedJavaType) {
-            throw new UnsupportedFeatureException(source.toString());
-        } else if (source instanceof HotSpotSignature) {
-            throw new UnsupportedFeatureException(source.toString());
-        } else if (source instanceof HotSpotObjectConstant) {
-            throw new UnsupportedFeatureException(source.toString());
-        } else if (source instanceof ResolvedJavaMethod && !(source instanceof SubstrateMethod)) {
-            dest = createMethod((ResolvedJavaMethod) source);
-        } else if (source instanceof ResolvedJavaField && !(source instanceof SubstrateField)) {
-            dest = createField((ResolvedJavaField) source);
-        } else if (source instanceof ResolvedJavaType && !(source instanceof SubstrateType)) {
-            dest = createType((ResolvedJavaType) source);
+        } else if (source instanceof ResolvedJavaMethod) {
+            if (source instanceof OriginalMethodProvider) {
+                dest = createMethod((ResolvedJavaMethod) source);
+            } else if (!(source instanceof SharedRuntimeMethod)) {
+                throw new UnsupportedFeatureException(source.toString());
+            }
+        } else if (source instanceof ResolvedJavaField) {
+            if (source instanceof OriginalFieldProvider) {
+                dest = createField((ResolvedJavaField) source);
+            } else if (!(source instanceof SubstrateField)) {
+                throw new UnsupportedFeatureException(source.toString());
+            }
+        } else if (source instanceof ResolvedJavaType) {
+            if (source instanceof OriginalClassProvider) {
+                dest = createType((ResolvedJavaType) source);
+            } else if (!(source instanceof SubstrateType)) {
+                throw new UnsupportedFeatureException(source.toString());
+            }
+        } else if (source instanceof Signature) {
+            if (source instanceof ResolvedSignature) {
+                dest = createSignature((ResolvedSignature<AnalysisType>) source);
+            } else if (!(source instanceof SubstrateSignature || source instanceof TruffleDebugJavaMethod.TruffleSignature)) {
+                throw new UnsupportedFeatureException(source.toString());
+            }
+        } else if (source instanceof JavaConstant cst) {
+            if (source instanceof ImageHeapConstant heapConstant) {
+                dest = SubstrateGraalUtils.hostedToRuntime(heapConstant, beforeAnalysisAccess.getBigBang().getConstantReflectionProvider());
+            } else if (cst.getJavaKind().isObject() && !cst.isDefaultForKind() && !(cst instanceof SubstrateObjectConstant)) {
+                throw new UnsupportedFeatureException(source.toString());
+            }
         } else if (source instanceof FieldLocationIdentity && !(source instanceof SubstrateFieldLocationIdentity)) {
             dest = createFieldLocationIdentity((FieldLocationIdentity) source);
-        } else if (source instanceof ImageHeapConstant heapConstant) {
-            dest = SubstrateGraalUtils.hostedToRuntime(heapConstant, beforeAnalysisAccess.getBigBang().getConstantReflectionProvider());
         }
 
         assert dest != null;

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/NativeImageGenerator.java

@@ -1798,8 +1798,8 @@ public static void checkName(String name, AnalysisMethod method, BigBang bb) {
         /*
          * We do not want any parts of the native image generator in the generated image. Therefore,
          * no element whose name contains "hosted" must be seen as reachable by the static analysis.
-         * The same holds for "hotspot" elements, which come from the hosting HotSpot VM, unless
-         * they are JDK internal types.
+         * The same holds for "host VM" elements, which come from the hosting VM, unless they are
+         * JDK internal types.
          */
         String message = checkName(name);
         if (message != null) {

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ameta/FieldValueInterceptionSupport.java

@@ -41,7 +41,6 @@
 import com.oracle.graal.pointsto.infrastructure.OriginalFieldProvider;
 import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisType;
-import com.oracle.graal.pointsto.meta.BaseLayerField;
 import com.oracle.graal.pointsto.util.GraalAccess;
 import com.oracle.svm.core.BuildPhaseProvider;
 import com.oracle.svm.core.RuntimeAssertionsSupport;
@@ -66,7 +65,6 @@
 import jdk.graal.compiler.nodes.java.LoadFieldNode;
 import jdk.graal.compiler.nodes.spi.CoreProviders;
 import jdk.graal.compiler.word.Word;
-import jdk.vm.ci.hotspot.HotSpotResolvedJavaField;
 import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.JavaKind;
 import jdk.vm.ci.meta.ResolvedJavaField;
@@ -115,7 +113,7 @@ public void registerFieldValueTransformer(Field reflectionField, FieldValueTrans
     }
 
     public void registerFieldValueTransformer(ResolvedJavaField oField, FieldValueTransformer transformer) {
-        assert oField instanceof HotSpotResolvedJavaField : oField;
+        assert oField != null && !(oField instanceof OriginalFieldProvider) : oField;
         if (annotationSubstitutions.isDeleted(oField)) {
             throw UserError.abort("Cannot register a field value transformer for field %s: %s", oField.format("%H.%n"),
                             "The field is marked as deleted, i.e., the field is not available on this platform");
@@ -155,8 +153,6 @@ private Object computeAndCacheFieldValueInterceptor(AnalysisField field) {
         field.beforeFieldValueAccess();
 
         ResolvedJavaField oField = OriginalFieldProvider.getOriginalField(field);
-        assert oField == null || oField instanceof HotSpotResolvedJavaField || oField instanceof BaseLayerField : oField;
-
         FieldValueComputer computer = createFieldValueComputer(field);
         Object result;
         if (computer != null) {

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ameta/SVMHostedValueProvider.java

@@ -42,7 +42,6 @@
 import com.oracle.svm.hosted.classinitialization.SimulateClassInitializerSupport;
 import com.oracle.svm.hosted.meta.RelocatableConstant;
 
-import jdk.vm.ci.hotspot.HotSpotObjectConstant;
 import jdk.vm.ci.meta.ConstantReflectionProvider;
 import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.PrimitiveConstant;
@@ -135,9 +134,9 @@ public <T> T asObject(Class<T> type, JavaConstant constant) {
      * object from ImageHeapInfo we reference a {@link ImageHeapConstant} which allows using
      * simulated constant as partition limits. However, since the original
      * {@link ConstantReflectionProvider} is not aware of {@link ImageHeapConstant} it always treats
-     * them as hosted objects and wraps them into a {@link HotSpotObjectConstant}. Therefore, we
-     * need intercept the {@link HotSpotObjectConstant} and if it wraps an {@link ImageHeapConstant}
-     * unwrap it and return the original constant.</li>
+     * them as hosted objects and wraps them into a host {@link JavaConstant}. Therefore, we need
+     * intercept the host {@link JavaConstant} and if it wraps an {@link ImageHeapConstant} unwrap
+     * it and return the original constant.</li>
      * <li>Second, intercept {@link WordBase} constants. See {@link #interceptWordType(Object)} for
      * details.</li>
      * </ul>

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/meta/HostedSnippetReflectionProvider.java

@@ -36,7 +36,6 @@
 
 import jdk.graal.compiler.api.replacements.SnippetReflectionProvider;
 import jdk.graal.compiler.word.WordTypes;
-import jdk.vm.ci.hotspot.HotSpotObjectConstant;
 import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.JavaKind;
 import jdk.vm.ci.meta.ResolvedJavaField;
@@ -80,8 +79,8 @@ public <T> T asObject(Class<T> type, JavaConstant c) {
                 return null;
             }
         }
-
-        if (type == Class.class && constant instanceof HotSpotObjectConstant) {
+        VMError.guarantee(!(constant instanceof ImageHeapConstant));
+        if (type == Class.class && constant.getJavaKind().isObject()) {
             /* Only unwrap the DynamicHub if a Class object is required explicitly. */
             if (heapScanner.getHostedValuesProvider().asObject(Object.class, constant) instanceof DynamicHub hub) {
                 return type.cast(hub.getHostedJavaClass());