More eagerly clear exception object frame states.

Author: teshull

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/java/BytecodeParser.java

@@ -1338,6 +1338,16 @@ protected void handleUnresolvedInvoke(JavaMethod javaMethod, InvokeKind invokeKi
         deopt.updateNodeSourcePosition(() -> createBytecodePosition());
     }
 
+    protected FrameStateBuilder createFrameStateForExceptionHandling(@SuppressWarnings("unused") int bci) {
+        FrameStateBuilder dispatchState = frameState.copy();
+        dispatchState.clearStack();
+        return dispatchState;
+    }
+
+    protected void clearNonLiveLocals(FrameStateBuilder state, BciBlock block, boolean liveIn) {
+        state.clearNonLiveLocals(block, liveness, liveIn);
+    }
+
     /**
      * @return the entry point to exception dispatch
      */
@@ -1346,8 +1356,7 @@ protected AbstractBeginNode handleException(ValueNode exceptionObject, int bci,
         assert bci == BytecodeFrame.BEFORE_BCI || bci == bci() : "invalid bci";
         debug.log("Creating exception dispatch edges at %d, exception object=%s, exception seen=%s", bci, exceptionObject, (profilingInfo == null ? "" : profilingInfo.getExceptionSeen(bci)));
 
-        FrameStateBuilder dispatchState = frameState.copy();
-        dispatchState.clearStack();
+        FrameStateBuilder dispatchState = createFrameStateForExceptionHandling(bci);
 
         AbstractBeginNode dispatchBegin;
         if (exceptionObject == null) {
@@ -1374,13 +1383,20 @@ protected AbstractBeginNode handleException(ValueNode exceptionObject, int bci,
         return dispatchBegin;
     }
 
-    protected void createHandleExceptionTarget(FixedWithNextNode afterExceptionLoaded, int bci, FrameStateBuilder dispatchState) {
+    private void createHandleExceptionTarget(FixedWithNextNode afterExceptionLoaded, int bci, FrameStateBuilder dispatchState) {
         FixedWithNextNode afterInstrumentation = afterExceptionLoaded;
         for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) {
             afterInstrumentation = plugin.instrumentExceptionDispatch(graph, afterInstrumentation, () -> dispatchState.create(bci, getNonIntrinsicAncestor(), false, null, null));
             assert afterInstrumentation.next() == null : "exception dispatch instrumentation will be linked to dispatch block";
         }
 
+        BciBlock dispatchBlock = getDispatchBlock(bci);
+
+        FixedNode target = createTarget(dispatchBlock, dispatchState);
+        afterInstrumentation.setNext(target);
+    }
+
+    protected BciBlock getDispatchBlock(int bci) {
         BciBlock dispatchBlock = currentBlock.exceptionDispatchBlock();
         /*
          * The exception dispatch block is always for the last bytecode of a block, so if we are not
@@ -1391,8 +1407,7 @@ protected void createHandleExceptionTarget(FixedWithNextNode afterExceptionLoade
             dispatchBlock = blockMap.getUnwindBlock();
         }
 
-        FixedNode target = createTarget(dispatchBlock, dispatchState);
-        afterInstrumentation.setNext(target);
+        return dispatchBlock;
     }
 
     protected ValueNode genLoadIndexed(ValueNode array, ValueNode index, GuardingNode boundsCheck, JavaKind kind) {

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/java/FrameStateBuilder.java

@@ -729,6 +729,9 @@ public boolean contains(ValueNode value) {
         return false;
     }
 
+    /**
+     * @param liveIn true if live in, false if live out
+     */
     public void clearNonLiveLocals(BciBlock block, LocalLiveness liveness, boolean liveIn) {
         /*
          * Non-live local clearing is mandatory for the entry block of an OSR compilation so that

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/AnalysisGraphBuilderPhase.java

@@ -25,7 +25,9 @@
 package com.oracle.svm.hosted.phases;
 
 import org.graalvm.compiler.core.common.BootstrapMethodIntrospection;
+import org.graalvm.compiler.java.BciBlockMapping;
 import org.graalvm.compiler.java.BytecodeParser;
+import org.graalvm.compiler.java.FrameStateBuilder;
 import org.graalvm.compiler.java.GraphBuilderPhase;
 import org.graalvm.compiler.nodes.CallTargetNode.InvokeKind;
 import org.graalvm.compiler.nodes.StructuredGraph;
@@ -43,6 +45,7 @@
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
 import com.oracle.svm.core.SubstrateOptions;
 import com.oracle.svm.hosted.SVMHost;
+import com.oracle.svm.hosted.code.SubstrateCompilationDirectives;
 import com.oracle.svm.util.ModuleSupport;
 
 import jdk.vm.ci.meta.JavaKind;
@@ -144,5 +147,24 @@ protected void genStoreField(ValueNode receiver, ResolvedJavaField field, ValueN
             hostVM.recordFieldStore(field, method);
             super.genStoreField(receiver, field, value);
         }
+
+        @Override
+        protected FrameStateBuilder createFrameStateForExceptionHandling(int bci) {
+            var dispatchState = super.createFrameStateForExceptionHandling(bci);
+            if (SubstrateOptions.parseOnce()) {
+                /*
+                 * It is beneficial to eagerly clear all non-live locals on the exception object
+                 * before entering the dispatch target. This helps us prune unneeded values from the
+                 * graph, which can positively impact our analysis. Since deoptimization is not
+                 * possible, then there is no risk in clearing the unneeded locals.
+                 */
+                AnalysisMethod aMethod = (AnalysisMethod) method;
+                if (aMethod.isOriginalMethod() && !SubstrateCompilationDirectives.singleton().isRegisteredForDeoptTesting(aMethod)) {
+                    BciBlockMapping.BciBlock dispatchBlock = getDispatchBlock(bci);
+                    clearNonLiveLocals(dispatchState, dispatchBlock, true);
+                }
+            }
+            return dispatchState;
+        }
     }
 }