[GR-39433] Allow instances of simulated classes in the image heap.

PullRequest: graal/12288

Author: cstancu

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/meta/CompressibleConstant.java renamed to compiler/src/org.graalvm.compiler.core.common/src/org/graalvm/compiler/core/common/type/CompressibleConstant.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 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
@@ -22,15 +22,15 @@
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
-package com.oracle.svm.core.meta;
+package org.graalvm.compiler.core.common.type;
 
-import jdk.vm.ci.meta.Constant;
+import jdk.vm.ci.meta.JavaConstant;
 
 // Subject to unification with HotspotConstant
-public interface CompressibleConstant extends Constant {
+public interface CompressibleConstant extends JavaConstant {
     boolean isCompressed();
 
-    Constant compress();
+    JavaConstant compress();
 
-    Constant uncompress();
+    JavaConstant uncompress();
 }

compiler/src/org.graalvm.compiler.core.common/src/org/graalvm/compiler/core/common/type/TypedConstant.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2022, 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 org.graalvm.compiler.core.common.type;
+
+import jdk.vm.ci.meta.JavaConstant;
+import jdk.vm.ci.meta.MetaAccessProvider;
+import jdk.vm.ci.meta.ResolvedJavaType;
+
+public interface TypedConstant extends JavaConstant {
+    ResolvedJavaType getType(MetaAccessProvider provider);
+}

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

@@ -63,7 +63,7 @@ public boolean forNullFieldValue(JavaConstant receiver, AnalysisField field, Sca
     @Override
     public boolean forNonNullFieldValue(JavaConstant receiver, AnalysisField field, JavaConstant fieldValue, ScanReason reason) {
         PointsToAnalysis analysis = getAnalysis();
-        AnalysisType fieldType = analysis.getMetaAccess().lookupJavaType(analysis.getSnippetReflectionProvider().asObject(Object.class, fieldValue).getClass());
+        AnalysisType fieldType = analysis.getMetaAccess().lookupJavaType(fieldValue);
 
         /* Add the constant value object to the field's type flow. */
         FieldTypeFlow fieldTypeFlow = getFieldTypeFlow(field, receiver);
@@ -87,7 +87,7 @@ private FieldTypeFlow getFieldTypeFlow(AnalysisField field, JavaConstant receive
              * constant object.
              */
             PointsToAnalysis analysis = getAnalysis();
-            AnalysisType receiverType = analysis.getMetaAccess().lookupJavaType(analysis.getSnippetReflectionProvider().asObject(Object.class, receiver).getClass());
+            AnalysisType receiverType = analysis.getMetaAccess().lookupJavaType(receiver);
             AnalysisObject constantReceiverObj = analysis.analysisPolicy().createConstantObject(analysis, receiver, receiverType);
             return constantReceiverObj.getInstanceFieldFlow(analysis, field, true);
         }

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

@@ -37,6 +37,8 @@
 import org.graalvm.word.WordBase;
 
 import com.oracle.graal.pointsto.constraints.UnsupportedFeatureException;
+import com.oracle.graal.pointsto.heap.ImageHeapArray;
+import com.oracle.graal.pointsto.heap.ImageHeapConstant;
 import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
 import com.oracle.graal.pointsto.meta.AnalysisType;
@@ -164,7 +166,7 @@ protected final void scanField(AnalysisField field, JavaConstant receiver, ScanR
                                 System.lineSeparator() + backtrace);
             }
 
-            if (fieldValue.getJavaKind() == JavaKind.Object && bb.getHostVM().isRelocatedPointer(constantAsObject(bb, fieldValue))) {
+            if (fieldValue.getJavaKind() == JavaKind.Object && bb.getHostVM().isRelocatedPointer(bb.getMetaAccess(), fieldValue)) {
                 scanningObserver.forRelocatedPointerFieldValue(receiver, field, fieldValue, reason);
             } else if (fieldValue.isNull()) {
                 scanningObserver.forNullFieldValue(receiver, field, reason);
@@ -191,45 +193,60 @@ protected final void scanField(AnalysisField field, JavaConstant receiver, ScanR
      */
     protected final void scanArray(JavaConstant array, ScanReason prevReason) {
 
-        Object valueObj = constantAsObject(bb, array);
-        AnalysisType arrayType = analysisType(bb, valueObj);
-        assert valueObj instanceof Object[];
-
+        AnalysisType arrayType = bb.getMetaAccess().lookupJavaType(array);
         ScanReason reason = new ArrayScan(arrayType, array, prevReason);
-        Object[] arrayObject = (Object[]) valueObj;
-        for (int idx = 0; idx < arrayObject.length; idx++) {
-            Object e = arrayObject[idx];
-            if (e == null) {
-                scanningObserver.forNullArrayElement(array, arrayType, idx, reason);
-            } else {
-                try {
-                    Object element = bb.getUniverse().replaceObject(e);
-                    JavaConstant elementConstant = bb.getSnippetReflectionProvider().forObject(element);
-                    AnalysisType elementType = analysisType(bb, element);
-                    /* First notify the observer about the array element value... */
-                    scanningObserver.forNonNullArrayElement(array, arrayType, elementConstant, elementType, idx, reason);
-                    /*
-                     * ... and only then scan the new value, i.e., follow its references. The order
-                     * is important for observers that expect to see the receiver before any of its
-                     * referenced elements are being scanned.
-                     */
-                    scanConstant(elementConstant, reason);
-                } catch (UnsupportedFeatureException ex) {
-                    unsupportedFeatureDuringConstantScan(bb, bb.getSnippetReflectionProvider().forObject(e), ex, reason);
+
+        if (array instanceof ImageHeapConstant) {
+            if (!arrayType.getComponentType().isPrimitive()) {
+                ImageHeapArray heapArray = (ImageHeapArray) array;
+                for (int idx = 0; idx < heapArray.getLength(); idx++) {
+                    final JavaConstant element = heapArray.getElement(idx);
+                    if (element.isNull()) {
+                        scanningObserver.forNullArrayElement(array, arrayType, idx, reason);
+                    } else {
+                        scanArrayElement(array, arrayType, reason, idx, element);
+                    }
+                }
+            }
+        } else {
+            Object[] arrayObject = (Object[]) constantAsObject(bb, array);
+            for (int idx = 0; idx < arrayObject.length; idx++) {
+                Object e = arrayObject[idx];
+                if (e == null) {
+                    scanningObserver.forNullArrayElement(array, arrayType, idx, reason);
+                } else {
+                    try {
+                        JavaConstant element = bb.getSnippetReflectionProvider().forObject(bb.getUniverse().replaceObject(e));
+                        scanArrayElement(array, arrayType, reason, idx, element);
+                    } catch (UnsupportedFeatureException ex) { /* Object replacement can throw. */
+                        unsupportedFeatureDuringConstantScan(bb, bb.getSnippetReflectionProvider().forObject(e), ex, reason);
+                    }
                 }
             }
         }
     }
 
+    private void scanArrayElement(JavaConstant array, AnalysisType arrayType, ScanReason reason, int idx, JavaConstant elementConstant) {
+        AnalysisType elementType = bb.getMetaAccess().lookupJavaType(elementConstant);
+        /* First notify the observer about the array element value... */
+        scanningObserver.forNonNullArrayElement(array, arrayType, elementConstant, elementType, idx, reason);
+        /*
+         * ... and only then scan the new value, i.e., follow its references. The order is important
+         * for observers that expect to see the receiver before any of its referenced elements are
+         * being scanned.
+         */
+        scanConstant(elementConstant, reason);
+    }
+
     public final void scanConstant(JavaConstant value, ScanReason reason) {
-        Object valueObj = constantAsObject(bb, value);
-        if (valueObj == null || valueObj instanceof WordBase) {
+        if (value.isNull() || bb.getMetaAccess().isInstanceOf(value, WordBase.class)) {
             return;
         }
         if (!bb.scanningPolicy().scanConstant(bb, value)) {
-            bb.markTypeInHeap(analysisType(bb, valueObj));
+            bb.markTypeInHeap(bb.getMetaAccess().lookupJavaType(value));
             return;
         }
+        Object valueObj = (value instanceof ImageHeapConstant) ? value : constantAsObject(bb, value);
         if (scannedObjects.putAndAcquire(valueObj) == null) {
             try {
                 scanningObserver.forScannedConstant(value, reason);
@@ -316,14 +333,17 @@ public static String asString(BigBang bb, JavaConstant constant) {
     }
 
     public static String asString(BigBang bb, JavaConstant constant, boolean appendToString) {
-        if (constant == null) {
+        if (constant == null || constant.isNull()) {
             return "null";
         }
-        Object obj = constantAsObject(bb, constant);
-        if (obj == null) {
-            return "null";
+        AnalysisType type = bb.getMetaAccess().lookupJavaType(constant);
+        if (constant instanceof ImageHeapConstant) {
+            // Checkstyle: allow Class.getSimpleName
+            return constant.getClass().getSimpleName() + "<" + type.toJavaName() + ">";
+            // Checkstyle: disallow Class.getSimpleName
         }
-        String str = analysisType(bb, obj).toJavaName() + '@' + Integer.toHexString(System.identityHashCode(obj));
+        Object obj = constantAsObject(bb, constant);
+        String str = type.toJavaName() + '@' + Integer.toHexString(System.identityHashCode(obj));
         if (appendToString) {
             try {
                 str += ": " + limit(obj.toString(), 80).replace(System.lineSeparator(), "");
@@ -351,10 +371,8 @@ public static String limit(String value, int length) {
      * element constants.
      */
     private void doScan(WorklistEntry entry) {
-        Object valueObj = constantAsObject(bb, entry.constant);
-
         try {
-            AnalysisType type = analysisType(bb, valueObj);
+            AnalysisType type = bb.getMetaAccess().lookupJavaType(entry.constant);
             type.registerAsReachable();
 
             if (type.isInstanceClass()) {
@@ -392,10 +410,6 @@ protected void finish() {
         }
     }
 
-    protected static AnalysisType analysisType(BigBang bb, Object constant) {
-        return bb.getMetaAccess().lookupJavaType(constant.getClass());
-    }
-
     public static AnalysisType constantType(BigBang bb, JavaConstant constant) {
         return bb.getMetaAccess().lookupJavaType(constant);
     }

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/api/HostVM.java

@@ -45,12 +45,14 @@
 import org.graalvm.nativeimage.hosted.Feature.DuringAnalysisAccess;
 
 import com.oracle.graal.pointsto.BigBang;
+import com.oracle.graal.pointsto.infrastructure.UniverseMetaAccess;
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
 import com.oracle.graal.pointsto.meta.AnalysisType;
 import com.oracle.graal.pointsto.meta.AnalysisUniverse;
 import com.oracle.graal.pointsto.meta.HostedProviders;
 import com.oracle.graal.pointsto.phases.InlineBeforeAnalysisPolicy;
 
+import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
 
@@ -78,9 +80,10 @@ public OptionValues options() {
     /**
      * Check if the provided object is a relocated pointer.
      * 
-     * @param originalObject the object to check
+     * @param metaAccess the meta-access provider
+     * @param constant the constant to check
      */
-    public boolean isRelocatedPointer(Object originalObject) {
+    public boolean isRelocatedPointer(UniverseMetaAccess metaAccess, JavaConstant constant) {
         return false;
     }
 

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/MethodTypeFlowBuilder.java

@@ -430,7 +430,8 @@ protected void apply() {
                         AnalysisType type = (AnalysisType) StampTool.typeOrNull(node);
                         assert type.isInstantiated();
                         TypeFlowBuilder<ConstantTypeFlow> sourceBuilder = TypeFlowBuilder.create(bb, node, ConstantTypeFlow.class, () -> {
-                            ConstantTypeFlow constantSource = new ConstantTypeFlow(sourcePosition(node), type, TypeState.forConstant(this.bb, node.asJavaConstant(), type));
+                            JavaConstant heapConstant = bb.getUniverse().getHeapScanner().toImageHeapObject(node.asJavaConstant());
+                            ConstantTypeFlow constantSource = new ConstantTypeFlow(sourcePosition(node), type, TypeState.forConstant(this.bb, heapConstant, type));
                             flowsGraph.addMiscEntryFlow(constantSource);
                             return constantSource;
                         });

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/context/object/AnalysisObject.java

@@ -289,14 +289,8 @@ public boolean isObjectArray() {
      */
     public static boolean isEmptyObjectArrayConstant(PointsToAnalysis bb, JavaConstant constant) {
         assert constant.getJavaKind() == JavaKind.Object;
-        Object valueObj = bb.getProviders().getSnippetReflection().asObject(Object.class, constant);
-        if (valueObj instanceof Object[]) {
-            Object[] arrayValueObj = (Object[]) valueObj;
-            if (arrayValueObj.length == 0) {
-                return true;
-            }
-        }
-        return false;
+        Integer length = bb.getConstantReflectionProvider().readArrayLength(constant);
+        return length != null && length == 0;
     }
 
     @Override