[dart2wasm] Emit unreachable instructions after calls that never return

This allows wasm optimizers as well as wasm runtimes to optimize code
better as they know calls to slow paths that throw will never return.


Change-Id: Iace1827062dbe00ce24c737b6369bf588e748ee9
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/404582
Reviewed-by: Ömer Ağacan <[email protected]>
Commit-Queue: Martin Kustermann <[email protected]>

Author: mkustermann

pkg/dart2wasm/lib/code_generator.dart

@@ -3941,7 +3941,6 @@ class StaticFieldImplicitAccessorCodeGenerator extends AstCodeGenerator {
     } else {
       if (flag != null) {
         // Explicit initialization flag
-        assert(global.type.type == initFunction.type.outputs.single);
         b.global_get(flag);
         b.if_(const [], [global.type.type]);
         b.global_get(global);
@@ -4291,6 +4290,24 @@ enum _VirtualCallKind {
 }
 
 extension MacroAssembler on w.InstructionsBuilder {
+  /// If the given [outputs] of a call contain bottom types then we will emit an
+  /// `unreachable` instruction.
+  ///
+  /// This can help wasm compilers / wasm runtimes to optimize things more as
+  /// they know control flow has ended here.
+  List<w.ValueType> emitUnreachableIfNoResult(List<w.ValueType> outputs) {
+    for (int i = 0; i < outputs.length; ++i) {
+      final output = outputs[i];
+      if (output is w.RefType &&
+          output.heapType == w.HeapType.none &&
+          !output.nullable) {
+        unreachable();
+        break;
+      }
+    }
+    return outputs;
+  }
+
   /// `[i32] -> [i32]`
   ///
   /// Consumes a `i32` class ID, leaves an `i32` as `bool` for whether
@@ -4620,8 +4637,7 @@ extension MacroAssembler on w.InstructionsBuilder {
       comment('Direct call to ${target.name}');
       call(target.function);
     }
-
-    return target.signature.outputs;
+    return emitUnreachableIfNoResult(target.signature.outputs);
   }
 
   /// Pushes fields common to all Dart objects (class id, id hash).

pkg/dart2wasm/lib/dispatch_table.dart

@@ -152,7 +152,7 @@ class SelectorInfo {
       for (int i = 0; i < returnCount; i++) {
         if (i < returns.length) {
           DartType type = returns[i];
-          outputSets[i].add(translator.translateType(type));
+          outputSets[i].add(translator.translateReturnType(type));
         } else {
           outputSets[i].add(translator.topInfo.nullableType);
         }

pkg/dart2wasm/lib/functions.dart

@@ -490,6 +490,9 @@ w.FunctionType _makeFunctionType(
   w.ValueType translateType(DartType type) => isImportOrExport
       ? translator.translateExternalType(type)
       : translator.translateType(type);
+  w.ValueType translateReturnType(DartType type) => isImportOrExport
+      ? translator.translateExternalType(type)
+      : translator.translateReturnType(type);
 
   final List<w.ValueType> inputs = _getInputTypes(
       translator, target, receiverType, isImportOrExport, translateType);
@@ -508,7 +511,8 @@ w.FunctionType _makeFunctionType(
     outputs = const [];
   } else {
     final DartType returnType = translator.typeOfReturnValue(member);
-    outputs = !isVoidType(returnType) ? [translateType(returnType)] : const [];
+    outputs =
+        !isVoidType(returnType) ? [translateReturnType(returnType)] : const [];
   }
 
   return translator.typesBuilder.defineFunction(inputs, outputs);

pkg/dart2wasm/lib/translator.dart

@@ -482,7 +482,7 @@ class Translator with KernelNodes {
       b.ref_as_non_null();
       b.call_ref(function.type);
     }
-    return function.type.outputs;
+    return b.emitUnreachableIfNoResult(function.type.outputs);
   }
 
   void callDispatchTable(w.InstructionsBuilder b, SelectorInfo selector) {
@@ -493,6 +493,7 @@ class Translator with KernelNodes {
       b.i32_add();
     }
     b.call_indirect(selector.signature, dispatchTable.getWasmTable(b.module));
+    b.emitUnreachableIfNoResult(selector.signature.outputs);
     functions.recordSelectorUse(selector);
   }
 
@@ -544,6 +545,13 @@ class Translator with KernelNodes {
   w.Tag getExceptionTag(w.ModuleBuilder module) =>
       exceptionTag.getExceptionTag(module);
 
+  w.ValueType translateReturnType(DartType type) {
+    if (type is NeverType && !type.isPotentiallyNullable) {
+      return const w.RefType.none(nullable: false);
+    }
+    return translateType(type);
+  }
+
   w.ValueType translateType(DartType type) {
     w.StorageType wasmType = translateStorageType(type);
     if (wasmType is w.ValueType) return wasmType;
@@ -640,7 +648,22 @@ class Translator with KernelNodes {
     if (type is DynamicType || type is VoidType) {
       return topInfo.nullableType;
     }
-    if (type is NullType || type is NeverType) {
+    if (type is NullType) {
+      return const w.RefType.none(nullable: true);
+    }
+    if (type is NeverType) {
+      // We should translate `Never` to a bottom type in wasm. Though right now
+      // for examples like this
+      //    ```
+      //    Never a;
+      //    try {
+      //      a = throw 'a;
+      //    } catch (e, s) {}
+      //    ```
+      // our code generator makes a local for `a` and tries to initialize it
+      // with a default value (of which there are none if we make it real
+      // bottom).
+      // => We make it nullable here.
       return const w.RefType.none(nullable: true);
     }
     if (type is TypeParameterType) {
@@ -1194,10 +1217,6 @@ class Translator with KernelNodes {
     return translateType(typeOfParameterVariable(node, isRequired));
   }
 
-  w.ValueType translateTypeOfReturnValue(Member node) {
-    return translateType(typeOfReturnValue(node));
-  }
-
   w.ValueType translateTypeOfField(Field node) {
     return translateType(typeOfField(node));
   }