Implement try_table based exception handling

This is now the default

Author: patrick96

web-image/mx.web-image/mx_web_image.py

@@ -63,7 +63,7 @@
     "web-image:WEBIMAGE_CLOSURE_SUPPORT",
     "web-image:WEBIMAGE_GOOGLE_CLOSURE",
 ]
-# Hosted options defined in the web-image-enterprise suite
+# Hosted options defined in the web-image suite
 # This list has to be kept in sync with the code (the 'webimageoptions' gate tag checks this)
 # See also WebImageConfiguration.hosted_options
 web_image_hosted_options = [
@@ -92,6 +92,7 @@
     "GrowthTriggerThreshold=",
     "HeapGrowthFactor=",
     "ImageHeapObjectsPerFunction=",
+    "LegacyExceptions",
     "JSComments=",
     "JSRuntime=",
     "LogFilter=",

web-image/src/com.oracle.svm.hosted.webimage/src/com/oracle/svm/hosted/webimage/NativeImageWasmGeneratorRunner.java

@@ -54,7 +54,6 @@
 import com.oracle.svm.hosted.webimage.options.WebImageOptions.CompilerBackend;
 import com.oracle.svm.hosted.webimage.util.BenchmarkLogger;
 import com.oracle.svm.hosted.webimage.wasm.WebImageWasmLMJavaMainSupport;
-import com.oracle.svm.hosted.webimage.wasm.codegen.BinaryenCompat;
 import com.oracle.svm.hosted.webimage.wasmgc.WebImageWasmGCJavaMainSupport;
 import com.oracle.svm.webimage.WebImageJSJavaMainSupport;
 import com.oracle.svm.webimage.WebImageJavaMainSupport;
@@ -167,11 +166,6 @@ public int build(ImageClassLoader classLoader) {
             // For the Wasm backends, turn off closure compiler
             optionProvider.getHostedValues().put(WebImageOptions.ClosureCompiler, false);
 
-            if (backend == CompilerBackend.WASMGC && !optionProvider.getHostedValues().containsKey(BinaryenCompat.Options.UseBinaryen)) {
-                // For WasmGC backend, use binaryen by default
-                optionProvider.getHostedValues().put(BinaryenCompat.Options.UseBinaryen, true);
-            }
-
             if (!optionProvider.getHostedValues().containsKey(WebImageOptions.NamingConvention)) {
                 // The naming convention does not affect the binary image (unless debug information
                 // is embedded) and the REDUCED mode makes the text file a lot easier to read

web-image/src/com.oracle.svm.hosted.webimage/src/com/oracle/svm/hosted/webimage/codegen/reconstruction/stackifier/StackifierData.java

@@ -58,6 +58,8 @@ public class StackifierData implements ReconstructionData {
      */
     private HIRBlock[] blocks;
 
+    private ControlFlowGraph cfg;
+
     /**
      * Mapping from a basic block to its index in {@link #blocks}.
      */
@@ -92,6 +94,10 @@ public HIRBlock[] getBlocks() {
         return blocks;
     }
 
+    public ControlFlowGraph getCfg() {
+        return cfg;
+    }
+
     public EconomicMap<HIRBlock, Scope> getEnclosingScope() {
         return enclosingScope;
     }
@@ -134,6 +140,7 @@ public void setLabeledBlockEnd(EconomicMap<HIRBlock, LabeledBlock> labeledBlockE
 
     public void setSortedBlocks(HIRBlock[] sortedBlocks, ControlFlowGraph cfg) {
         this.blocks = sortedBlocks;
+        this.cfg = cfg;
         this.blockIndexSortOrder = new BlockMap<>(cfg);
         for (int i = 0; i < sortedBlocks.length; ++i) {
             this.blockIndexSortOrder.put(sortedBlocks[i], i);

web-image/src/com.oracle.svm.hosted.webimage/src/com/oracle/svm/hosted/webimage/wasm/WebImageWasmOptions.java

@@ -49,6 +49,9 @@ public class WebImageWasmOptions {
                     "Has no effect on code size, the binary format does not have comments.")//
     public static final EnumOptionKey<CommentVerbosity> WasmComments = new EnumOptionKey<>(CommentVerbosity.NORMAL);
 
+    @Option(help = "Enable the legacy exception proposal using try-catch instead of try_table") //
+    public static final HostedOptionKey<Boolean> LegacyExceptions = new HostedOptionKey<>(false);
+
     @Option(help = "Assemble the Wasm binary file with debug names.")//
     public static final HostedOptionKey<Boolean> DebugNames = new HostedOptionKey<>(false) {
 

web-image/src/com.oracle.svm.hosted.webimage/src/com/oracle/svm/hosted/webimage/wasm/codegen/BinaryenCompat.java

@@ -27,11 +27,17 @@
 
 import java.util.Objects;
 
+import org.graalvm.collections.UnmodifiableEconomicMap;
+
 import com.oracle.svm.core.option.HostedOptionKey;
+import com.oracle.svm.hosted.webimage.options.WebImageOptions;
+import com.oracle.svm.hosted.webimage.wasm.WebImageWasmOptions;
 import com.oracle.svm.hosted.webimage.wasm.ast.visitors.WasmPrinter;
 import com.oracle.svm.webimage.wasm.types.WasmValType;
 
 import jdk.graal.compiler.options.Option;
+import jdk.graal.compiler.options.OptionKey;
+import jdk.graal.compiler.options.OptionValues;
 import jdk.vm.ci.code.site.Reference;
 
 /**
@@ -43,7 +49,23 @@ public class BinaryenCompat {
 
     public static class Options {
         @Option(help = "Use Binaryen (wasm-as) to assemble the final Wasm binary")//
-        public static final HostedOptionKey<Boolean> UseBinaryen = new HostedOptionKey<>(false);
+        public static final HostedOptionKey<Boolean> UseBinaryen = new HostedOptionKey<>(false) {
+            @Override
+            public Boolean getValue(OptionValues values) {
+                assert checkDescriptorExists();
+                return getValueOrDefault(values.getMap());
+            }
+
+            @Override
+            public Boolean getValueOrDefault(UnmodifiableEconomicMap<OptionKey<?>, Object> values) {
+                if (values.containsKey(this)) {
+                    return (Boolean) values.get(this);
+                }
+
+                // Binaryen is the default for WasmGC or when the new exception handling is used.
+                return WebImageOptions.getBackend() == WebImageOptions.CompilerBackend.WASMGC || !WebImageWasmOptions.LegacyExceptions.getValueOrDefault(values);
+            }
+        };
     }
 
     public static boolean usesBinaryen() {

web-image/src/com.oracle.svm.hosted.webimage/src/com/oracle/svm/hosted/webimage/wasm/codegen/WasmIRWalker.java

@@ -35,6 +35,8 @@
 import java.util.Map;
 import java.util.stream.Stream;
 
+import com.oracle.svm.hosted.webimage.wasm.WebImageWasmOptions;
+import com.oracle.svm.hosted.webimage.wasm.ast.id.WebImageWasmIds;
 import org.graalvm.collections.Pair;
 
 import com.oracle.svm.core.graal.nodes.ReadExceptionObjectNode;
@@ -184,13 +186,16 @@ protected void predeclareVariables(StructuredGraph graph) {
      *
      * @param currentBlock block from which to jump from
      * @param successor target of the jump
+     * @return Whether a jump was generated
      */
-    private void generateForwardJump(HIRBlock currentBlock, HIRBlock successor) {
+    private boolean generateForwardJump(HIRBlock currentBlock, HIRBlock successor) {
         WasmId.Label id = getForwardJumpTarget(currentBlock, successor);
 
         if (id != null) {
             masm.genInst(new Break(id), "forward jump");
+            return true;
         }
+        return false;
     }
 
     private WasmId.Label getForwardJumpTarget(HIRBlock currentBlock, HIRBlock successor) {
@@ -278,6 +283,85 @@ protected void lowerLoopEnd(LoopEndNode loopEnd) {
     /**
      * Lower a WithExceptionNode.
      *
+     * @param currentBlock basic block that ends with {@link WithExceptionNode}
+     * @param lastNode the {@link WithExceptionNode}
+     * @see #lowerWithExceptionExnRef(HIRBlock, WithExceptionNode)
+     * @see #lowerWithExceptionLegacy(HIRBlock, WithExceptionNode)
+     */
+    @Override
+    protected void lowerWithException(HIRBlock currentBlock, WithExceptionNode lastNode) {
+        assert currentBlock.getEndNode() == lastNode : currentBlock.toString(Verbosity.Name);
+        if (WebImageWasmOptions.LegacyExceptions.getValue()) {
+            lowerWithExceptionLegacy(currentBlock, lastNode);
+        } else {
+            lowerWithExceptionExnRef(currentBlock, lastNode);
+        }
+    }
+
+    /**
+     * Lower a WithExceptionNode using the exnref exception handling proposal.
+     *
+     * <pre>
+     * {@code
+     * (block $exnBlock (result $throwable)
+     *     (try_table (catch $exc_tag $exnBlock)
+     *         WithExceptionNode();
+     *         br Successor
+     *     )
+     * )
+     * (local.set $exc_var)
+     * ExceptionEdge();
+     * }
+     * </pre>
+     *
+     * The {@link WithExceptionNode} is wrapped in a {@code try_table} block, which is surrounded by
+     * a block that's the target of the catch scope. After the block around the {@code try_table}
+     * instruction, the thrown value is already on the stack, we store it in a dedicated local
+     * variable ({@link WebImageWasmNodeLowerer#exceptionObjectVariable}) so that it can be read
+     * later by {@link ReadExceptionObjectNode}. The
+     * {@link com.oracle.svm.hosted.webimage.wasm.phases.WasmLabeledBlockGeneration} ensures that
+     * the regular successor always requires a forward jump.
+     *
+     * @see #lowerWithException(HIRBlock, WithExceptionNode)
+     */
+    protected void lowerWithExceptionExnRef(HIRBlock currentBlock, WithExceptionNode lastNode) {
+        WebImageWasmIds.InternalLabel exceptionHandlerLabel = masm.idFactory.newInternalLabel("exn" + currentBlock.getId());
+        Instruction.Block exceptionTargetBlock = new Instruction.Block(exceptionHandlerLabel, masm.getWasmProviders().util().getThrowableType());
+        masm.genInst(exceptionTargetBlock);
+
+        masm.childScope(exceptionTargetBlock.instructions, exceptionTargetBlock);
+        Instruction.TryTable tryBlock = new Instruction.TryTable(null);
+        tryBlock.addCatch(masm.getKnownIds().getJavaThrowableTag(), exceptionHandlerLabel);
+        masm.genInst(tryBlock, lastNode);
+
+        masm.childScope(tryBlock.instructions, tryBlock);
+        lowerNode(lastNode);
+        HIRBlock normSucc = cfg.blockFor(lastNode.next());
+        boolean didJump = generateForwardJump(currentBlock, normSucc);
+        GraalError.guarantee(didJump, "No jump was inserted after a WithExceptionNode");
+        masm.parentScope(tryBlock);
+
+        masm.parentScope(exceptionTargetBlock);
+
+        masm.genInst(masm.nodeLowerer().exceptionObjectVariable.setter(new Instruction.Nop()), "Store exception object");
+        masm.lowerCatchPreamble();
+
+        CatchScopeContainer scopeEntry = (CatchScopeContainer) stackifierData.getScopeEntry(lastNode);
+        Scope catchScope = scopeEntry.getCatchScope();
+        if (catchScope != null) {
+            lowerBlocks(catchScope.getSortedBlocks(stackifierData));
+            // Just a sanity check
+            masm.genInst(new Unreachable(), "End of catch block is unreachable, it must break out");
+        } else {
+            HIRBlock excpSucc = cfg.blockFor(lastNode.exceptionEdge());
+            boolean didJumpAfterCatch = generateForwardJump(currentBlock, excpSucc);
+            GraalError.guarantee(didJumpAfterCatch, "No jump was inserted in catch block");
+        }
+    }
+
+    /**
+     * Lower a WithExceptionNode using the legacy exception handling proposal.
+     *
      * <pre>
      * {@code
      * (try
@@ -301,13 +385,9 @@ protected void lowerLoopEnd(LoopEndNode loopEnd) {
      * ({@link WebImageWasmNodeLowerer#exceptionObjectVariable}) so that it can be read later by
      * {@link ReadExceptionObjectNode}.
      *
-     * @param currentBlock basic block that ends with {@link WithExceptionNode}
-     * @param lastNode the {@link WithExceptionNode}
+     * @see #lowerWithException(HIRBlock, WithExceptionNode)
      */
-    @Override
-    protected void lowerWithException(HIRBlock currentBlock, WithExceptionNode lastNode) {
-        assert currentBlock.getEndNode() == lastNode : currentBlock.toString(Verbosity.Name);
-
+    protected void lowerWithExceptionLegacy(HIRBlock currentBlock, WithExceptionNode lastNode) {
         Instruction.Try tryBlock = new Instruction.Try(null);
         masm.genInst(tryBlock, lastNode);
 

web-image/src/com.oracle.svm.hosted.webimage/src/com/oracle/svm/hosted/webimage/wasm/phases/WasmLabeledBlockGeneration.java

@@ -28,6 +28,8 @@
 import com.oracle.svm.hosted.webimage.codegen.reconstruction.stackifier.LabeledBlockGeneration;
 import com.oracle.svm.hosted.webimage.codegen.reconstruction.stackifier.StackifierData;
 
+import com.oracle.svm.hosted.webimage.wasm.WebImageWasmOptions;
+import jdk.graal.compiler.nodes.WithExceptionNode;
 import jdk.graal.compiler.nodes.cfg.ControlFlowGraph;
 import jdk.graal.compiler.nodes.cfg.HIRBlock;
 
@@ -53,6 +55,19 @@ public boolean isLabeledBlockNeeded(HIRBlock block, HIRBlock successor) {
             return true;
         }
 
+        if (!WebImageWasmOptions.LegacyExceptions.getValue() && block.getEndNode() instanceof WithExceptionNode withExceptionNode) {
+            HIRBlock normSucc = stackifierData.getCfg().blockFor(withExceptionNode.next());
+            if (normSucc.equals(successor)) {
+                /*
+                 * With the new exception handling, we need an explicit labeled block when going
+                 * from the WithExceptionNode to its regular successor because in the Wasm code, the
+                 * successor does not appear directly after, the catch block does, and we would then
+                 * fall through to that.
+                 */
+                return true;
+            }
+        }
+
         return false;
     }
 }