Clean up resources created by the constant expression analysis after they are no longer needed.

Author: Aca-S

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/strictconstantanalysis/ConstantExpressionRegistry.java

@@ -39,18 +39,22 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 public class ConstantExpressionRegistry {
 
     private static final Object NULL_MARKER = new Object();
 
-    private final Map<Pair<ResolvedJavaMethod, Integer>, AbstractFrame<ConstantExpressionAnalyzer.Value>> registry;
+    private Map<Pair<ResolvedJavaMethod, Integer>, AbstractFrame<ConstantExpressionAnalyzer.Value>> registry;
+    private final AtomicBoolean isSealed = new AtomicBoolean();
 
     public ConstantExpressionRegistry() {
         registry = new ConcurrentHashMap<>();
+        isSealed.set(false);
     }
 
     public void analyzeAndStore(ConstantExpressionAnalyzer analyzer, ResolvedJavaMethod method, IntrinsicContext intrinsicContext) {
+        VMError.guarantee(!isSealed(), "Registry is already sealed");
         Bytecode bytecode = getBytecode(method, intrinsicContext);
         try {
             Map<Integer, AbstractFrame<ConstantExpressionAnalyzer.Value>> abstractFrames = analyzer.analyze(bytecode);
@@ -68,6 +72,7 @@ private static Bytecode getBytecode(ResolvedJavaMethod method, IntrinsicContext
     }
 
     public Optional<Object> getReceiver(ResolvedJavaMethod callerMethod, int bci, ResolvedJavaMethod targetMethod) {
+        VMError.guarantee(!isSealed(), "Registry is already sealed");
         VMError.guarantee(targetMethod.hasReceiver(), "Receiver requested for static method");
         AbstractFrame<ConstantExpressionAnalyzer.Value> frame = registry.get(Pair.create(callerMethod, bci));
         if (frame == null) {
@@ -96,6 +101,7 @@ public <T> T getReceiver(ResolvedJavaMethod callerMethod, int bci, ResolvedJavaM
     }
 
     public Optional<Object> getArgument(ResolvedJavaMethod callerMethod, int bci, ResolvedJavaMethod targetMethod, int index) {
+        VMError.guarantee(!isSealed(), "Registry is already sealed");
         int numOfParameters = targetMethod.getSignature().getParameterCount(false);
         VMError.guarantee(index >= 0 && index < numOfParameters, "Argument index out of bounds");
         AbstractFrame<ConstantExpressionAnalyzer.Value> frame = registry.get(Pair.create(callerMethod, bci));
@@ -142,6 +148,15 @@ public <T> T getArgument(ResolvedJavaMethod callerMethod, int bci, ResolvedJavaM
         return type.cast(argumentValue);
     }
 
+    public boolean isSealed() {
+        return isSealed.get();
+    }
+
+    public void seal() {
+        isSealed.set(true);
+        registry = null;
+    }
+
     public static boolean isNull(Object object) {
         return object == NULL_MARKER;
     }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/strictconstantanalysis/InferredDynamicAccessLoggingFeature.java

@@ -60,7 +60,7 @@ static class Options {
         static final HostedOptionKey<String> InferredDynamicAccessLog = new HostedOptionKey<>(null);
     }
 
-    private static final Queue<LogEntry> log = new ConcurrentLinkedQueue<>();
+    private static Queue<LogEntry> log = new ConcurrentLinkedQueue<>();
 
     public static void logConstant(GraphBuilderContext b, ParsingReason reason, ResolvedJavaMethod targetMethod, Object targetReceiver, Object[] targetArguments, Object value) {
         logEntry(b, reason, () -> new ConstantLogEntry(b, targetMethod, targetReceiver, targetArguments, value));
@@ -77,6 +77,7 @@ public static void logRegistration(GraphBuilderContext b, ParsingReason reason,
 
     private static void logEntry(GraphBuilderContext b, ParsingReason reason, Supplier<LogEntry> entrySupplier) {
         if (reason.duringAnalysis() && reason != ParsingReason.JITCompilation && isEnabled()) {
+            VMError.guarantee(log != null, "Logging attempt when log has been sealed");
             LogEntry entry = entrySupplier.get();
             b.add(ReachabilityRegistrationNode.create(() -> log.add(entry), reason));
         }
@@ -100,6 +101,12 @@ public void afterAnalysis(AfterAnalysisAccess access) {
         if (shouldWarnForNonStrictFolding()) {
             warnForNonStrictFolding();
         }
+        /* The log is no longer used after this, so we can clean it up. */
+        cleanLog();
+    }
+
+    private static void cleanLog() {
+        log = null;
     }
 
     private static void dump(String location) {
@@ -140,13 +147,13 @@ private static boolean registryContainsConstantOperands(ConstantExpressionRegist
         Pair<ResolvedJavaMethod, Integer> callLocation = entry.callLocation;
         if (entry.targetMethod.hasReceiver()) {
             Optional<Object> receiver = registry.getReceiver(callLocation.getLeft(), callLocation.getRight(), entry.targetMethod);
-            if (entry.targetReceiver != IGNORED_ARGUMENT_MARKER && receiver.isEmpty()) {
+            if (entry.targetReceiver != ignoredArgument() && receiver.isEmpty()) {
                 return false;
             }
         }
         for (int i = 0; i < entry.targetArguments.length; i++) {
             Optional<Object> argument = registry.getArgument(callLocation.getLeft(), callLocation.getRight(), entry.targetMethod, i);
-            if (entry.targetArguments[i] != IGNORED_ARGUMENT_MARKER && argument.isEmpty()) {
+            if (entry.targetArguments[i] != ignoredArgument() && argument.isEmpty()) {
                 return false;
             }
         }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/strictconstantanalysis/StrictConstantAnalysisFeature.java

@@ -145,6 +145,16 @@ public void registerInvocationPlugins(Providers providers, GraphBuilderConfigura
         plugins.appendMethodParsingPlugin((method, intrinsicContext) -> registry.analyzeAndStore(analyzer, method, intrinsicContext));
     }
 
+    @Override
+    public void afterAnalysis(AfterAnalysisAccess access) {
+        /*
+         * No more bytecode parsing should happen after analysis, so we can seal and clean up the
+         * registry.
+         */
+        ConstantExpressionRegistry registry = ImageSingletons.lookup(ConstantExpressionRegistry.class);
+        registry.seal();
+    }
+
     /**
      * Utility method which attempts to infer {@code targetMethod} according to the {@code Disable},
      * {@code Warn} and {@code Enforce} options of {@code StrictConstantAnalysis}.