[GR-42996] Ensure no SubstrateObjectConstant in Graal graphs.

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/GraphEncoder.java

@@ -518,7 +518,7 @@ public boolean verifyEncoding(StructuredGraph originalGraph, EncodedGraph encode
                         recordInlinedMethods(originalGraph.isRecordingInlinedMethods()).
                         build();
         // @formatter:off
-        GraphDecoder decoder = new GraphDecoder(architecture, decodedGraph);
+        GraphDecoder decoder = graphDecoderForVerification(decodedGraph);
         decoder.decode(encodedGraph);
 
         decodedGraph.verify();
@@ -533,6 +533,10 @@ public boolean verifyEncoding(StructuredGraph originalGraph, EncodedGraph encode
         }
         return optimizationLogCodec.verify(originalGraph, decodedGraph) && inliningLogCodec.verify(originalGraph, decodedGraph);
     }
+
+    protected GraphDecoder graphDecoderForVerification(StructuredGraph decodedGraph) {
+        return new GraphDecoder(architecture, decodedGraph);
+    }
 }
 
 class GraphComparison {
@@ -580,7 +584,7 @@ public static boolean verifyGraphsEqual(StructuredGraph expectedGraph, Structure
                 for (int i = 0; i < nodeClass.getData().getCount(); i++) {
                     Object expectedProperty = nodeClass.getData().get(expectedNode, i);
                     Object actualProperty = nodeClass.getData().get(actualNode, i);
-                    assert Objects.equals(expectedProperty, actualProperty);
+                    assert Objects.equals(expectedProperty, actualProperty): "Expected " + expectedProperty + ", found " + actualProperty;
                 }
             }
 

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/nodes/ObjectLocationIdentity.java

@@ -26,10 +26,10 @@
 
 import java.util.Objects;
 
-import jdk.graal.compiler.nodes.util.JavaConstantFormattable;
-import jdk.graal.compiler.nodes.util.JavaConstantFormatter;
 import org.graalvm.word.LocationIdentity;
 
+import jdk.graal.compiler.nodes.util.JavaConstantFormattable;
+import jdk.graal.compiler.nodes.util.JavaConstantFormatter;
 import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.JavaKind;
 
@@ -50,6 +50,10 @@ private ObjectLocationIdentity(JavaConstant object) {
         this.object = object;
     }
 
+    public JavaConstant getObject() {
+        return object;
+    }
+
     @Override
     public boolean equals(Object obj) {
         if (obj instanceof ObjectLocationIdentity) {

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/ConstantReflectionProviderExtension.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2023, 2023, 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.graal.pointsto;
+
+import com.oracle.graal.pointsto.infrastructure.UniverseMetaAccess;
+
+import jdk.vm.ci.meta.ConstantReflectionProvider;
+import jdk.vm.ci.meta.JavaConstant;
+import jdk.vm.ci.meta.ResolvedJavaField;
+
+public interface ConstantReflectionProviderExtension<T extends ResolvedJavaField> extends ConstantReflectionProvider {
+    JavaConstant readHostedFieldValue(UniverseMetaAccess access, T field, JavaConstant receiver);
+}

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/ObjectScanner.java

@@ -125,6 +125,10 @@ private void execute(Runnable runnable) {
     }
 
     protected void scanEmbeddedRoot(JavaConstant root, BytecodePosition position) {
+        if (root instanceof ImageHeapConstant ihc && ihc.getHostedObject() == null) {
+            /* Skip embedded simulated constants. */
+            return;
+        }
         try {
             EmbeddedRootScan reason = new EmbeddedRootScan(position, root);
             scanningObserver.forEmbeddedRoot(root, reason);
@@ -160,6 +164,11 @@ protected void scanField(AnalysisField field, JavaConstant receiver, ScanReason
             assert isUnwrapped(receiver) : receiver;
 
             JavaConstant fieldValue = readFieldValue(field, receiver);
+            if (fieldValue instanceof ImageHeapConstant ihc && ihc.getHostedObject() == null) {
+                /* Skip reachable simulated constants. */
+                return;
+            }
+
             if (fieldValue == null) {
                 StringBuilder backtrace = new StringBuilder();
                 buildObjectBacktrace(bb, reason, backtrace);
@@ -181,7 +190,7 @@ protected void scanField(AnalysisField field, JavaConstant receiver, ScanReason
                  * referenced elements are being scanned.
                  */
                 scanConstant(fieldValue, reason);
-            } else if (fieldValue.getJavaKind().isNumericInteger()) {
+            } else if (fieldValue.getJavaKind().isPrimitive()) {
                 scanningObserver.forPrimitiveFieldValue(receiver, field, fieldValue, reason);
             }
 
@@ -190,8 +199,9 @@ protected void scanField(AnalysisField field, JavaConstant receiver, ScanReason
         }
     }
 
+    @SuppressWarnings("unchecked")
     protected JavaConstant readFieldValue(AnalysisField field, JavaConstant receiver) {
-        return bb.getConstantReflectionProvider().readFieldValue(field, receiver);
+        return ((ConstantReflectionProviderExtension<AnalysisField>) bb.getConstantReflectionProvider()).readHostedFieldValue(bb.getMetaAccess(), field, receiver);
     }
 
     /**
@@ -423,7 +433,7 @@ private void doScan(WorklistEntry entry) {
                         scanField(field, entry.constant, entry.reason);
                     }
                 }
-            } else if (type.isArray() && bb.getWordTypes().asKind(type.getComponentType()) == JavaKind.Object) {
+            } else if (type.isArray() && type.getComponentType().getJavaKind() == JavaKind.Object) {
                 /* Scan the array elements. */
                 scanArray(entry.constant, entry.reason);
             }

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

@@ -25,6 +25,7 @@
 package com.oracle.graal.pointsto.heap;
 
 import static com.oracle.graal.pointsto.ObjectScanner.ScanReason;
+import static com.oracle.graal.pointsto.ObjectScanner.constantAsObject;
 
 import java.util.Objects;
 import java.util.function.Consumer;
@@ -46,6 +47,7 @@
 import jdk.graal.compiler.options.OptionKey;
 import jdk.graal.compiler.options.OptionType;
 import jdk.vm.ci.meta.JavaConstant;
+import jdk.vm.ci.meta.JavaKind;
 
 public class HeapSnapshotVerifier {
 
@@ -144,15 +146,7 @@ public ScanningObserver() {
 
         @Override
         public boolean forRelocatedPointerFieldValue(JavaConstant receiver, AnalysisField field, JavaConstant fieldValue, ScanReason reason) {
-            boolean result = false;
-            ObjectScanningObserver scanningObserver = scanner.getScanningObserver();
-            if (scanningObserver != null) {
-                result = scanningObserver.forRelocatedPointerFieldValue(receiver, field, fieldValue, reason);
-                if (result) {
-                    analysisModified = true;
-                }
-            }
-            return result;
+            return verifyFieldValue(receiver, field, fieldValue, reason);
         }
 
         @Override
@@ -162,15 +156,7 @@ public boolean forPrimitiveFieldValue(JavaConstant receiver, AnalysisField field
 
         @Override
         public boolean forNullFieldValue(JavaConstant receiver, AnalysisField field, ScanReason reason) {
-            boolean result = false;
-            ObjectScanningObserver scanningObserver = scanner.getScanningObserver();
-            if (scanningObserver != null) {
-                result = scanningObserver.forNullFieldValue(receiver, field, reason);
-                if (result) {
-                    analysisModified = true;
-                }
-            }
-            return result;
+            return verifyFieldValue(receiver, field, JavaConstant.NULL_POINTER, reason);
         }
 
         @Override
@@ -204,8 +190,10 @@ private void verifyStaticFieldValue(TypeData typeData, AnalysisField field, Java
                 Consumer<ScanReason> onAnalysisModified = analysisModified(reason, format, field, unwrappedSnapshot, fieldValue);
                 result = scanner.patchStaticField(typeData, field, fieldValue, reason, onAnalysisModified).ensureDone();
                 heapPatched = true;
+            } else if (patchPrimitiveArrayValue(fieldSnapshot, fieldValue)) {
+                heapPatched = true;
             }
-            ImageHeapScanner.ensureReaderInstalled(result);
+            scanner.ensureReaderInstalled(result);
         }
 
         private void verifyInstanceFieldValue(AnalysisField field, JavaConstant receiver, ImageHeapInstance receiverObject, JavaConstant fieldSnapshot, JavaConstant fieldValue, ScanReason reason) {
@@ -216,8 +204,10 @@ private void verifyInstanceFieldValue(AnalysisField field, JavaConstant receiver
                 Consumer<ScanReason> onAnalysisModified = analysisModified(reason, format, field, asString(receiver), unwrappedSnapshot, fieldValue);
                 result = scanner.patchInstanceField(receiverObject, field, fieldValue, reason, onAnalysisModified).ensureDone();
                 heapPatched = true;
+            } else if (patchPrimitiveArrayValue(fieldSnapshot, fieldValue)) {
+                heapPatched = true;
             }
-            ImageHeapScanner.ensureReaderInstalled(result);
+            scanner.ensureReaderInstalled(result);
         }
 
         private Consumer<ScanReason> analysisModified(ScanReason reason, String format, Object... args) {
@@ -235,41 +225,71 @@ private Consumer<ScanReason> analysisModified(ScanReason reason, String format,
         }
 
         @Override
-        public boolean forNullArrayElement(JavaConstant array, AnalysisType arrayType, int elementIndex, ScanReason reason) {
-            boolean result = false;
-            ObjectScanningObserver scanningObserver = scanner.getScanningObserver();
-            if (scanningObserver != null) {
-                result = scanningObserver.forNullArrayElement(array, arrayType, elementIndex, reason);
-                if (result) {
-                    analysisModified = true;
-                }
-            }
-            return result;
+        public boolean forNullArrayElement(JavaConstant array, AnalysisType arrayType, int index, ScanReason reason) {
+            return verifyArrayElementValue(JavaConstant.NULL_POINTER, index, reason, array);
         }
 
         @Override
         public boolean forNonNullArrayElement(JavaConstant array, AnalysisType arrayType, JavaConstant elementValue, AnalysisType elementType, int index, ScanReason reason) {
+            return verifyArrayElementValue(elementValue, index, reason, array);
+        }
+
+        private boolean verifyArrayElementValue(JavaConstant elementValue, int index, ScanReason reason, JavaConstant array) {
+            ImageHeapObjectArray arrayObject = (ImageHeapObjectArray) getSnapshot(array, reason);
             /*
              * We don't care if an array element in the shadow heap was not yet read, i.e., the
              * future is not yet materialized. This can happen with values originating from lazy
              * fields that become available but may have not yet been consumed. We simply execute
              * the future, then compare the produced value.
              */
-            ImageHeapObjectArray arrayObject = (ImageHeapObjectArray) getSnapshot(array, reason);
             JavaConstant elementSnapshot = arrayObject.readElementValue(index);
-            verifyArrayElementValue(elementValue, index, reason, array, arrayObject, elementSnapshot);
-            return false;
-        }
-
-        private void verifyArrayElementValue(JavaConstant elementValue, int index, ScanReason reason, JavaConstant array, ImageHeapObjectArray arrayObject, JavaConstant elementSnapshot) {
             JavaConstant result = elementSnapshot;
             if (!Objects.equals(maybeUnwrapSnapshot(elementSnapshot, elementValue instanceof ImageHeapConstant), elementValue)) {
                 String format = "Value mismatch for array element at index %s of %s %n snapshot:  %s %n new value: %s %n";
                 Consumer<ScanReason> onAnalysisModified = analysisModified(reason, format, index, asString(array), elementSnapshot, elementValue);
                 result = scanner.patchArrayElement(arrayObject, index, elementValue, reason, onAnalysisModified).ensureDone();
                 heapPatched = true;
+            } else if (patchPrimitiveArrayValue(elementSnapshot, elementValue)) {
+                heapPatched = true;
+            }
+            scanner.ensureReaderInstalled(result);
+            return false;
+        }
+
+        /**
+         * {@link ImageHeapPrimitiveArray} clones the original primitive array and keeps a reference
+         * to the original hosted object. The original hosted array can change value, so we use a
+         * deep equals to check element equality. This method assumes and checks that the originally
+         * shadowed object did not change since if that happens then the entire constant should have
+         * been patched instead.
+         */
+        private boolean patchPrimitiveArrayValue(JavaConstant snapshot, JavaConstant newValue) {
+            if (snapshot.isNull()) {
+                AnalysisError.guarantee(newValue.isNull());
+                return false;
             }
-            ImageHeapScanner.ensureReaderInstalled(result);
+            if (isPrimitiveArrayConstant(snapshot)) {
+                AnalysisError.guarantee(isPrimitiveArrayConstant(newValue));
+                Object snapshotArray = ((ImageHeapPrimitiveArray) snapshot).getArray();
+                Object newValueArray = constantAsObject(bb, newValue);
+                if (!Objects.deepEquals(snapshotArray, newValueArray)) {
+                    /* Guarantee that the shadowed constant and the hosted constant are the same. */
+                    AnalysisError.guarantee(bb.getConstantReflectionProvider().constantEquals(snapshot, newValue));
+                    Integer length = bb.getConstantReflectionProvider().readArrayLength(newValue);
+                    /* Since the shadowed constant didn't change, the length should match. */
+                    System.arraycopy(newValueArray, 0, snapshotArray, 0, length);
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        private boolean isPrimitiveArrayConstant(JavaConstant snapshot) {
+            if (snapshot.getJavaKind() == JavaKind.Object) {
+                AnalysisType type = bb.getMetaAccess().lookupJavaType(snapshot);
+                return type.isArray() && type.getComponentType().getJavaKind() != JavaKind.Object;
+            }
+            return false;
         }
 
         @SuppressWarnings({"unchecked", "rawtypes"})

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

@@ -45,7 +45,7 @@ public class ImageHeap {
      * not-yet-executed {@link AnalysisFuture} of {@link ImageHeapConstant} or its results, an
      * {@link ImageHeapConstant}. Not all objects in this cache are reachable.
      */
-    private final ConcurrentHashMap<JavaConstant, /* ImageHeapObject */ Object> objectsCache;
+    private final ConcurrentHashMap<JavaConstant, /* ImageHeapConstant */ Object> objectsCache;
     /** Store a mapping from types to object snapshots. */
     private final Map<AnalysisType, Set<ImageHeapConstant>> reachableObjects;
 
@@ -78,7 +78,7 @@ public ImageHeap() {
     /** Get the constant snapshot from the cache. */
     public Object getSnapshot(JavaConstant constant) {
         if (constant instanceof ImageHeapConstant imageHeapConstant) {
-            assert imageHeapConstant.getHostedObject() == null || objectsCache.get(imageHeapConstant.getHostedObject()) == imageHeapConstant;
+            assert imageHeapConstant.getHostedObject() == null || objectsCache.get(imageHeapConstant.getHostedObject()).equals(imageHeapConstant);
             return imageHeapConstant;
         }
         return objectsCache.get(constant);

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

@@ -257,14 +257,14 @@ public boolean equals(Object o) {
              * the previous behavior where the raw object was extracted and used as a key when
              * constructing the image heap map.
              */
-            return this.constantData == other.constantData;
+            return this.constantData == other.constantData && this.compressed == other.compressed;
         }
         return false;
     }
 
     @Override
     public int hashCode() {
-        return constantData.hashCode();
+        return constantData.hashCode() + (compressed ? 1 : 0);
     }
 
     @Override

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

@@ -119,7 +119,7 @@ public void onFieldRead(AnalysisField field) {
         AnalysisType declaringClass = field.getDeclaringClass();
         if (field.isStatic()) {
             if (isValueAvailable(field)) {
-                JavaConstant fieldValue = declaringClass.getOrComputeData().readFieldValue(field);
+                JavaConstant fieldValue = readStaticFieldValue(field);
                 markReachable(fieldValue, reason);
                 notifyAnalysis(field, null, fieldValue, reason);
             } else if (field.canBeNull()) {
@@ -178,6 +178,13 @@ void markTypeInstantiated(AnalysisType type, ScanReason reason) {
         universe.getBigbang().registerTypeAsInHeap(type, reason);
     }
 
+    public JavaConstant getImageHeapConstant(JavaConstant constant) {
+        if (isNonNullObjectConstant(constant)) {
+            return (ImageHeapConstant) imageHeap.getSnapshot(constant);
+        }
+        return constant;
+    }
+
     public JavaConstant createImageHeapConstant(JavaConstant constant, ScanReason reason) {
         if (isNonNullObjectConstant(constant)) {
             return getOrCreateImageHeapConstant(constant, reason);
@@ -527,6 +534,14 @@ protected String formatReason(String message, ScanReason reason) {
         return message + ' ' + reason;
     }
 
+    /**
+     * Redirect static fields reading. The implementors can overwrite this and provide additional
+     * sources for static fields values.
+     */
+    public JavaConstant readStaticFieldValue(AnalysisField field) {
+        return field.getDeclaringClass().getOrComputeData().readFieldValue(field);
+    }
+
     protected ValueSupplier<JavaConstant> readHostedFieldValue(AnalysisField field, JavaConstant receiver) {
         // Wrap the hosted constant into a substrate constant
         JavaConstant value = universe.fromHosted(constantReflection.readFieldValue(field, receiver));
@@ -583,8 +598,8 @@ public void rescanField(Object receiver, Field reflectionField) {
      * a wrong snapshot, we need to manually ensure that the readers are installed since the
      * verification will continue expanding them.
      */
-    static void ensureReaderInstalled(JavaConstant constant) {
-        if (constant.getJavaKind() == JavaKind.Object && constant.isNonNull()) {
+    void ensureReaderInstalled(JavaConstant constant) {
+        if (isNonNullObjectConstant(constant)) {
             ((ImageHeapConstant) constant).ensureReaderInstalled();
         }
     }
@@ -697,10 +712,6 @@ public void cleanupAfterAnalysis() {
         scanningObserver = null;
     }
 
-    public ObjectScanningObserver getScanningObserver() {
-        return scanningObserver;
-    }
-
     protected abstract Class<?> getClass(String className);
 
     protected AnalysisType lookupJavaType(String className) {