[GR-10670] Corrupt frame state when handling deleted fields with --report-unsupported-elements-at-runtime.

PullRequest: graal/1766

Author: mukel

compiler/src/org.graalvm.compiler.java/src/org/graalvm/compiler/java/BytecodeParser.java

@@ -3543,6 +3543,11 @@ public void push(JavaKind slotKind, ValueNode value) {
         frameState.push(slotKind, value);
     }
 
+    @Override
+    public ValueNode pop(JavaKind slotKind) {
+        return frameState.pop(slotKind);
+    }
+
     @Override
     public ConstantReflectionProvider getConstantReflection() {
         return constantReflection;

compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/graphbuilderconf/GraphBuilderContext.java

@@ -35,6 +35,7 @@
 import org.graalvm.compiler.core.common.type.Stamp;
 import org.graalvm.compiler.core.common.type.StampFactory;
 import org.graalvm.compiler.core.common.type.StampPair;
+import org.graalvm.compiler.debug.GraalError;
 import org.graalvm.compiler.nodes.AbstractMergeNode;
 import org.graalvm.compiler.nodes.CallTargetNode;
 import org.graalvm.compiler.nodes.CallTargetNode.InvokeKind;
@@ -76,6 +77,16 @@ public interface GraphBuilderContext extends GraphBuilderTool {
      */
     void push(JavaKind kind, ValueNode value);
 
+    /**
+     * Pops a value from the frame state stack using an explicit kind.
+     *
+     * @param slotKind the kind to use when type checking this operation
+     * @return the value on the top of the stack
+     */
+    default ValueNode pop(JavaKind slotKind) {
+        throw GraalError.unimplemented();
+    }
+
     /**
      * Adds a node to the graph. If the node is in the graph, returns immediately. If the node is a
      * {@link StateSplit} with a null {@linkplain StateSplit#stateAfter() frame state}, the frame

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/DeletedFieldsPlugin.java

@@ -33,39 +33,52 @@
 import com.oracle.svm.core.annotate.Delete;
 import com.oracle.svm.core.meta.SubstrateObjectConstant;
 
+import jdk.vm.ci.meta.JavaKind;
 import jdk.vm.ci.meta.ResolvedJavaField;
+import jdk.vm.ci.meta.ResolvedJavaMethod;
 
 public final class DeletedFieldsPlugin implements NodePlugin {
 
     @Override
     public boolean handleLoadField(GraphBuilderContext b, ValueNode object, ResolvedJavaField field) {
-        return handleField(b, field);
+        return handleField(b, field, true);
     }
 
     @Override
     public boolean handleLoadStaticField(GraphBuilderContext b, ResolvedJavaField field) {
-        return handleField(b, field);
+        return handleField(b, field, true);
     }
 
     @Override
     public boolean handleStoreField(GraphBuilderContext b, ValueNode object, ResolvedJavaField field, ValueNode value) {
-        return handleField(b, field);
+        return handleField(b, field, false);
     }
 
     @Override
     public boolean handleStoreStaticField(GraphBuilderContext b, ResolvedJavaField field, ValueNode value) {
-        return handleField(b, field);
+        return handleField(b, field, false);
     }
 
-    private static boolean handleField(GraphBuilderContext b, ResolvedJavaField field) {
+    private static boolean handleField(GraphBuilderContext b, ResolvedJavaField field, boolean isLoad) {
         Delete deleteAnnotation = field.getAnnotation(Delete.class);
         if (deleteAnnotation == null) {
             return false;
         }
 
         String msg = AnnotationSubstitutionProcessor.deleteErrorMessage(field, deleteAnnotation, false);
         ValueNode msgNode = ConstantNode.forConstant(SubstrateObjectConstant.forObject(msg), b.getMetaAccess(), b.getGraph());
-        b.handleReplacedInvoke(InvokeKind.Static, b.getMetaAccess().lookupJavaMethod(DeletedMethod.reportErrorMethod), new ValueNode[]{msgNode}, false);
+        ResolvedJavaMethod reportErrorMethod = b.getMetaAccess().lookupJavaMethod(DeletedMethod.reportErrorMethod);
+        b.handleReplacedInvoke(InvokeKind.Static, reportErrorMethod, new ValueNode[]{msgNode}, false);
+
+        JavaKind returnKind = reportErrorMethod.getSignature().getReturnKind();
+        if (returnKind != JavaKind.Void) {
+            b.pop(returnKind);
+        }
+        if (isLoad) {
+            // Push dummy value.
+            b.addPush(field.getJavaKind(), ConstantNode.defaultForKind(field.getJavaKind()));
+        }
+
         return true;
     }
 }