[dart2wasm] Outline <obj> is/as <type> checks to shared helper functions

This reduces in Flute size of optimized wasm by

  * 1.5% in -O3
  * 0.7% in -O4

We rely on binaryen to inline small enough checks (e.g. `is` check
with a single cid-range)

Change-Id: I8f2c093daebe47d6e066b8681c1e285fa5fa0ea0
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/351780
Reviewed-by: Slava Egorov <[email protected]>
Commit-Queue: Martin Kustermann <[email protected]>

Author: mkustermann

pkg/dart2wasm/lib/async.dart

@@ -1069,7 +1069,7 @@ class AsyncCodeGenerator extends CodeGenerator {
       if (emitGuard) {
         _getCurrentException();
         b.ref_as_non_null();
-        types.emitTypeCheck(this, catch_.guard,
+        types.emitIsTest(this, catch_.guard,
             translator.coreTypes.objectNonNullableRawType, catch_);
         b.i32_eqz();
         // When generating guards we can't generate the catch body inside the

pkg/dart2wasm/lib/code_generator.dart

@@ -1158,7 +1158,7 @@ class CodeGenerator extends ExpressionVisitor1<w.ValueType, w.ValueType>
       // Only emit the type test if the guard is not [Object].
       if (emitGuard) {
         b.local_get(thrownException);
-        types.emitTypeCheck(
+        types.emitIsTest(
             this, guard, translator.coreTypes.objectNonNullableRawType, catch_);
         b.i32_eqz();
         b.br_if(catchBlock);
@@ -3025,8 +3025,12 @@ class CodeGenerator extends ExpressionVisitor1<w.ValueType, w.ValueType>
 
   @override
   w.ValueType visitIsExpression(IsExpression node, w.ValueType expectedType) {
-    wrap(node.operand, translator.topInfo.nullableType);
-    types.emitTypeCheck(this, node.type, dartTypeOf(node.operand), node);
+    final operandType = dartTypeOf(node.operand);
+    final boxedOperandType = operandType.isPotentiallyNullable
+        ? translator.topInfo.nullableType
+        : translator.topInfo.nonNullableType;
+    wrap(node.operand, boxedOperandType);
+    types.emitIsTest(this, node.type, operandType, node);
     return w.NumType.i32;
   }
 
@@ -3036,23 +3040,13 @@ class CodeGenerator extends ExpressionVisitor1<w.ValueType, w.ValueType>
       return wrap(node.operand, expectedType);
     }
 
-    w.Label asCheckBlock = b.block();
-    wrap(node.operand, translator.topInfo.nullableType);
-    w.Local operand = addLocal(translator.topInfo.nullableType);
-    b.local_tee(operand);
-
-    // We lower an `as` expression to a type test, throwing a [TypeError] if
-    // the type test fails.
-    types.emitTypeCheck(this, node.type, dartTypeOf(node.operand), node);
-    b.br_if(asCheckBlock);
-    b.local_get(operand);
-    types.makeType(this, node.type);
-    call(translator.stackTraceCurrent.reference);
-    call(translator.throwAsCheckError.reference);
-    b.unreachable();
-    b.end();
-    b.local_get(operand);
-    return operand.type;
+    final operandType = dartTypeOf(node.operand);
+    final boxedOperandType = operandType.isPotentiallyNullable
+        ? translator.topInfo.nullableType
+        : translator.topInfo.nonNullableType;
+    wrap(node.operand, boxedOperandType);
+    return types.emitAsCheck(
+        this, node.type, operandType, boxedOperandType, node);
   }
 
   @override
@@ -3793,7 +3787,7 @@ enum _VirtualCallKind {
 extension MacroAssembler on w.InstructionsBuilder {
   // Expects there to be a i32 on the stack, will consume it and leave
   // true/false on the stack.
-  void emitClassIdRangeCheck(CodeGenerator codeGen, List<Range> ranges) {
+  void emitClassIdRangeCheck(List<Range> ranges) {
     if (ranges.isEmpty) {
       drop();
       i32_const(0);
@@ -3809,7 +3803,7 @@ extension MacroAssembler on w.InstructionsBuilder {
         i32_lt_u();
       }
     } else {
-      w.Local idLocal = codeGen.addLocal(w.NumType.i32);
+      w.Local idLocal = addLocal(w.NumType.i32, isParameter: false);
       local_set(idLocal);
       w.Label done = block(const [], const [w.NumType.i32]);
       i32_const(1);

pkg/dart2wasm/lib/intrinsics.dart

@@ -649,8 +649,7 @@ class Intrinsifier {
 
           codeGen.wrap(classId, w.NumType.i64);
           b.i32_wrap_i64();
-          b.emitClassIdRangeCheck(
-              codeGen, [Range(objectClassId, objectClassId)]);
+          b.emitClassIdRangeCheck([Range(objectClassId, objectClassId)]);
           return w.NumType.i32;
         case "_isClosureClassId":
           final classId = node.arguments.positional.single;
@@ -661,7 +660,7 @@ class Intrinsifier {
 
           codeGen.wrap(classId, w.NumType.i64);
           b.i32_wrap_i64();
-          b.emitClassIdRangeCheck(codeGen, ranges);
+          b.emitClassIdRangeCheck(ranges);
           return w.NumType.i32;
         case "_isRecordClassId":
           final classId = node.arguments.positional.single;
@@ -672,7 +671,7 @@ class Intrinsifier {
 
           codeGen.wrap(classId, w.NumType.i64);
           b.i32_wrap_i64();
-          b.emitClassIdRangeCheck(codeGen, ranges);
+          b.emitClassIdRangeCheck(ranges);
           return w.NumType.i32;
       }
     }

pkg/dart2wasm/lib/types.dart

@@ -567,17 +567,19 @@ class Types {
   /// Emit code for testing a value against a Dart type. Expects the value on
   /// the stack as a (ref null #Top) and leaves the result on the stack as an
   /// i32.
-  void emitTypeCheck(CodeGenerator codeGen, DartType type, DartType operandType,
+  void emitIsTest(CodeGenerator codeGen, DartType type, DartType operandType,
       [TreeNode? node]) {
     final b = codeGen.b;
     b.comment("Type check against $type");
     w.Local? operandTemp;
     if (translator.options.verifyTypeChecks) {
-      operandTemp = codeGen.addLocal(translator.topInfo.nullableType);
+      operandTemp =
+          b.addLocal(translator.topInfo.nullableType, isParameter: false);
       b.local_tee(operandTemp);
     }
-    if (!_emitOptimizedTypeCheck(codeGen, type, operandType)) {
-      // General fallback path
+    if (_canUseIsCheckHelper(codeGen, type, operandType)) {
+      b.call(_generateIsChecker(type as InterfaceType, operandType));
+    } else {
       makeType(codeGen, type);
       codeGen.call(translator.isSubtype.reference);
     }
@@ -597,15 +599,36 @@ class Types {
     }
   }
 
-  /// Emit optimized code for testing a value against a Dart type. If the type
-  /// to be tested against is of a shape where we can generate more efficient
-  /// code than the general fallback path, generate such code and return `true`.
-  /// Otherwise, return `false` to indicate that the general path should be
-  /// taken.
-  bool _emitOptimizedTypeCheck(
+  w.ValueType emitAsCheck(CodeGenerator codeGen, DartType type,
+      DartType operandType, w.RefType boxedOperandType,
+      [TreeNode? node]) {
+    final b = codeGen.b;
+
+    if (_canUseAsCheckHelper(codeGen, type, operandType)) {
+      b.call(_generateAsChecker(type as InterfaceType, operandType));
+      return translator.translateType(type);
+    }
+
+    w.Local operand = b.addLocal(boxedOperandType, isParameter: false);
+    b.local_tee(operand);
+    w.Label asCheckBlock = b.block();
+    b.local_get(operand);
+    emitIsTest(codeGen, type, operandType, node);
+    b.br_if(asCheckBlock);
+    b.local_get(operand);
+    makeType(codeGen, type);
+    codeGen.call(translator.stackTraceCurrent.reference);
+    codeGen.call(translator.throwAsCheckError.reference);
+    b.unreachable();
+    b.end();
+    return operand.type;
+  }
+
+  bool _canUseIsCheckHelper(
       CodeGenerator codeGen, DartType type, DartType operandType) {
-    if (type is! InterfaceType) return false;
+    if (_canUseAsCheckHelper(codeGen, type, operandType)) return true;
 
+    if (type is! InterfaceType) return false;
     if (type.typeArguments.any((t) => t is! DynamicType)) {
       // Type has at least one type argument that is not `dynamic`.
       //
@@ -627,43 +650,124 @@ class Types {
         return false;
       }
     }
+    return true;
+  }
 
-    final b = codeGen.b;
-    bool isPotentiallyNullable = operandType.isPotentiallyNullable;
-    w.Label? resultLabel;
-    if (isPotentiallyNullable) {
-      // Store operand in a temporary variable, since Binaryen does not support
-      // block inputs.
-      w.Local operand = codeGen.addLocal(translator.topInfo.nullableType);
-      b.local_set(operand);
-      resultLabel = b.block(const [], const [w.NumType.i32]);
-      w.Label nullLabel = b.block(const [], const []);
-      b.local_get(operand);
-      b.br_on_null(nullLabel);
-    }
+  bool _canUseAsCheckHelper(
+      CodeGenerator codeGen, DartType type, DartType operandType) {
+    if (type is! InterfaceType) return false;
+    // TODO: Should be rather defaults to bounds instead of `dynamic`.
+    // (assuming omitting bound will make it dynamic rather than void/Object?)
+    return type.typeArguments.every((t) => t is DynamicType);
+  }
+
+  final Map<DartType, w.BaseFunction> _nullableIsCheckers = {};
+  final Map<DartType, w.BaseFunction> _isCheckers = {};
 
+  w.BaseFunction _generateIsChecker(InterfaceType type, DartType operandType) {
+    final operandIsNullable = operandType.isPotentiallyNullable;
     final interfaceClass = type.classNode;
 
-    if (interfaceClass == coreTypes.objectClass) {
-      b.drop();
-      b.i32_const(1);
-    } else if (interfaceClass == coreTypes.functionClass) {
-      b.ref_test(translator.closureInfo.nonNullableType);
-    } else {
-      final ranges =
-          translator.classIdNumbering.getConcreteClassIdRanges(interfaceClass);
-      b.struct_get(translator.topInfo.struct, FieldIndex.classId);
-      b.emitClassIdRangeCheck(codeGen, ranges);
-    }
+    final cachedIsCheckers =
+        operandIsNullable ? _nullableIsCheckers : _isCheckers;
+
+    return cachedIsCheckers.putIfAbsent(type, () {
+      final argumentType = operandIsNullable
+          ? translator.topInfo.nullableType
+          : translator.topInfo.nonNullableType;
+      final function = translator.m.functions.define(
+          translator.m.types.defineFunction(
+            [argumentType],
+            [w.NumType.i32],
+          ),
+          '<obj> is <$type>');
+
+      final b = function.body;
+      b.local_get(b.locals[0]);
+
+      w.Label? resultLabel;
+      if (operandIsNullable) {
+        // Store operand in a temporary variable, since Binaryen does not support
+        // block inputs.
+        w.Local operand = function.addLocal(translator.topInfo.nullableType);
+        b.local_set(operand);
+        resultLabel = b.block(const [], const [w.NumType.i32]);
+        w.Label nullLabel = b.block(const [], const []);
+        b.local_get(operand);
+        b.br_on_null(nullLabel);
+      }
 
-    if (isPotentiallyNullable) {
-      b.br(resultLabel!);
-      b.end(); // nullLabel
-      b.i32_const(encodedNullability(type));
-      b.end(); // resultLabel
-    }
+      if (interfaceClass == coreTypes.objectClass) {
+        b.drop();
+        b.i32_const(1);
+      } else if (interfaceClass == coreTypes.functionClass) {
+        b.ref_test(translator.closureInfo.nonNullableType);
+      } else {
+        final ranges = translator.classIdNumbering
+            .getConcreteClassIdRanges(interfaceClass);
+        b.struct_get(translator.topInfo.struct, FieldIndex.classId);
+        b.emitClassIdRangeCheck(ranges);
+      }
 
-    return true;
+      if (operandIsNullable) {
+        b.br(resultLabel!);
+        b.end(); // nullLabel
+        b.i32_const(encodedNullability(type));
+        b.end(); // resultLabel
+      }
+
+      b.return_();
+      b.end();
+
+      return function;
+    });
+  }
+
+  final Map<DartType, w.BaseFunction> _nullableAsCheckers = {};
+  final Map<DartType, w.BaseFunction> _asCheckers = {};
+
+  w.BaseFunction _generateAsChecker(InterfaceType type, DartType operandType) {
+    final operandIsNullable = operandType.isPotentiallyNullable;
+    final cachedAsCheckers =
+        operandIsNullable ? _nullableAsCheckers : _asCheckers;
+
+    final returnType = translator.translateType(type);
+
+    return cachedAsCheckers.putIfAbsent(type, () {
+      final argumentType = operandIsNullable
+          ? translator.topInfo.nullableType
+          : translator.topInfo.nonNullableType;
+      final function = translator.m.functions.define(
+          translator.m.types.defineFunction(
+            [argumentType],
+            [returnType],
+          ),
+          '<obj> as <$type>');
+
+      final b = function.body;
+      w.Label asCheckBlock = b.block();
+      b.local_get(b.locals[0]);
+      b.call(_generateIsChecker(type, operandType));
+      b.br_if(asCheckBlock);
+
+      b.local_get(b.locals[0]);
+      translator.constants.instantiateConstant(
+          function, b, TypeLiteralConstant(type), nonNullableTypeType);
+      b.call(translator.functions
+          .getFunction(translator.stackTraceCurrent.reference));
+      b.call(translator.functions
+          .getFunction(translator.throwAsCheckError.reference));
+      b.unreachable();
+
+      b.end();
+
+      b.local_get(b.locals[0]);
+      translator.convertType(function, argumentType, returnType);
+      b.return_();
+      b.end();
+
+      return function;
+    });
   }
 
   int encodedNullability(DartType type) =>

pkg/wasm_builder/lib/src/builder/instructions.dart

@@ -251,6 +251,8 @@ class InstructionsBuilder with Builder<ir.Instructions> {
     return _stackTypes.sublist(_stackTypes.length - n);
   }
 
+  List<ir.ValueType> get stack => _stackTypes;
+
   List<ir.ValueType> _checkStackTypes(List<ir.ValueType> inputs,
       [List<ir.ValueType>? stack]) {
     stack ??= _stack(inputs.length);