[GR-73410] Update ObjectScanner#scanConstant and ObjectScanner.ReusableSet for Terminus

PullRequest: graal/23276

Author: d-kozak

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

@@ -29,7 +29,7 @@
 import java.util.Collection;
 import java.util.Comparator;
 import java.util.Deque;
-import java.util.IdentityHashMap;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ConcurrentLinkedDeque;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -304,12 +304,11 @@ public void scanConstant(JavaConstant value, ScanReason reason) {
             return;
         }
         JavaConstant unwrappedValue = maybeUnwrap(value);
-        Object valueObj = unwrappedValue instanceof ImageHeapConstant ? unwrappedValue : constantAsObject(bb, unwrappedValue);
-        if (scannedObjects.putAndAcquire(valueObj) == null) {
+        if (scannedObjects.putAndAcquire(unwrappedValue) == null) {
             try {
                 scanningObserver.forScannedConstant(unwrappedValue, reason);
             } finally {
-                scannedObjects.release(valueObj);
+                scannedObjects.release(unwrappedValue);
                 WorklistEntry worklistEntry = new WorklistEntry(unwrappedValue, reason);
                 if (executor != null) {
                     executor.execute(debug -> doScan(worklistEntry));
@@ -786,12 +785,16 @@ public static final class ReusableSet {
         /**
          * The storage of atomic integers. During analysis the constant count for rather large
          * programs such as the JS interpreter are 90k objects. Hence we use 64k as a good start.
+         * <p/>
+         * The specification of {@link Object#equals(Object)} and {@link Object#hashCode()}} for
+         * {@link JavaConstant} states that they are based on the identity of the wrapped object,
+         * thus we can use {@link JavaConstant} as keys here.
          */
-        private final IdentityHashMap<Object, AtomicInteger> store = new IdentityHashMap<>(65536);
+        private final HashMap<JavaConstant, AtomicInteger> store = new HashMap<>(65536);
         private int sequence = 0;
 
-        public Object putAndAcquire(Object object) {
-            IdentityHashMap<Object, AtomicInteger> map = this.store;
+        public Object putAndAcquire(JavaConstant object) {
+            Map<JavaConstant, AtomicInteger> map = this.store;
             AtomicInteger i = map.get(object);
             int seq = this.sequence;
             int inflightSequence = seq - 1;
@@ -824,14 +827,14 @@ public Object putAndAcquire(Object object) {
             }
         }
 
-        public void release(Object o) {
-            IdentityHashMap<Object, AtomicInteger> map = this.store;
-            AtomicInteger i = map.get(o);
+        public void release(JavaConstant object) {
+            Map<JavaConstant, AtomicInteger> map = this.store;
+            AtomicInteger i = map.get(object);
             if (i == null) {
                 // We have missed a value likely someone else has updated the map at the same time.
                 // Now synchronize
                 synchronized (map) {
-                    i = map.get(o);
+                    i = map.get(object);
                 }
             }
             i.set(sequence);