[VM/FFI] Adds FFI leaf calls.

This CL adds FFI leaf calls by adding `lookupFunction(.., isLeaf)`
and `_asFunctionInternal(.., isLeaf)`, which generate FFI leaf calls.
These calls skip a lot of the usual frame building and generated <->
native transition overhead.

`benchmark/FfiCall/` shows a 1.1x - 4.3x speed-up between the regular
FFI calls and their leaf call counterparts (JIT, x64, release).

TEST=Adds `tests/ffi{,_2}/vmspecific_leaf_call_test.dart`. Tested FFI tests.

Closes: #36707
Cq-Include-Trybots: luci.dart.try:vm-precomp-ffi-qemu-linux-release-arm-try,vm-ffi-android-release-arm64-try,vm-ffi-android-release-arm-try,vm-ffi-android-product-arm64-try,vm-ffi-android-product-arm-try,vm-ffi-android-debug-arm64-try,vm-ffi-android-debug-arm-try,vm-kernel-linux-debug-ia32-try,vm-kernel-win-debug-ia32-try,vm-kernel-win-debug-x64-try,vm-kernel-win-release-x64-try,vm-kernel-mac-debug-x64-try,vm-kernel-precomp-nnbd-mac-release-simarm64-try,vm-kernel-precomp-android-release-arm64-try,vm-kernel-precomp-asan-linux-release-x64-try,vm-kernel-precomp-linux-release-simarm_x64-try,vm-kernel-precomp-obfuscate-linux-release-x64-try,vm-kernel-precomp-ubsan-linux-release-x64-try,vm-kernel-precomp-tsan-linux-release-x64-try,vm-kernel-precomp-win-release-x64-try,vm-precomp-ffi-qemu-linux-release-arm-try,vm-kernel-reload-rollback-linux-debug-x64-try,vm-kernel-reload-linux-debug-x64-try
Bug: #36707
Change-Id: Id8824f36b0006bf09951207bd004356fe6e9f46e
Cq-Do-Not-Cancel-Tryjobs: true
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/179768
Commit-Queue: Clement Skau <[email protected]>
Reviewed-by: Daco Harkes <[email protected]>
Reviewed-by: Martin Kustermann <[email protected]>

Author: Clement Skau

benchmarks/FfiCall/dart/FfiCall.dart

@@ -3778,6 +3778,27 @@ const MessageCode messageFfiExpectedConstant = const MessageCode(
     "FfiExpectedConstant",
     message: r"""Exceptional return value must be a constant.""");
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<Message Function(String name)> templateFfiExpectedConstantArg =
+    const Template<Message Function(String name)>(
+        messageTemplate: r"""Argument '#name' must be a constant.""",
+        withArguments: _withArgumentsFfiExpectedConstantArg);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(String name)> codeFfiExpectedConstantArg =
+    const Code<Message Function(String name)>(
+  "FfiExpectedConstantArg",
+);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsFfiExpectedConstantArg(String name) {
+  if (name.isEmpty) throw 'No name provided';
+  name = demangleMixinApplicationName(name);
+  return new Message(codeFfiExpectedConstantArg,
+      message: """Argument '${name}' must be a constant.""",
+      arguments: {'name': name});
+}
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<Message Function(String name)>
     templateFfiExtendsOrImplementsSealedClass =
@@ -3931,6 +3952,24 @@ Message _withArgumentsFfiFieldNull(String name) {
       arguments: {'name': name});
 }
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeFfiLeafCallMustNotReturnHandle =
+    messageFfiLeafCallMustNotReturnHandle;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageFfiLeafCallMustNotReturnHandle = const MessageCode(
+    "FfiLeafCallMustNotReturnHandle",
+    message: r"""FFI leaf call must not have Handle return type.""");
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeFfiLeafCallMustNotTakeHandle =
+    messageFfiLeafCallMustNotTakeHandle;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageFfiLeafCallMustNotTakeHandle = const MessageCode(
+    "FfiLeafCallMustNotTakeHandle",
+    message: r"""FFI leaf call must not have Handle argument types.""");
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<
     Message Function(String name)> templateFfiNotStatic = const Template<

benchmarks/FfiCall/dart2/FfiCall.dart

@@ -462,6 +462,7 @@ const List<ErrorCode> errorCodeValues = [
   CompileTimeErrorCode.YIELD_IN_NON_GENERATOR,
   CompileTimeErrorCode.YIELD_OF_INVALID_TYPE,
   FfiCode.ANNOTATION_ON_POINTER_FIELD,
+  FfiCode.ARGUMENT_MUST_BE_A_CONSTANT,
   FfiCode.EMPTY_STRUCT,
   FfiCode.EXTRA_ANNOTATION_ON_STRUCT_FIELD,
   FfiCode.EXTRA_SIZE_ANNOTATION_CARRAY,
@@ -470,6 +471,8 @@ const List<ErrorCode> errorCodeValues = [
   FfiCode.GENERIC_STRUCT_SUBCLASS,
   FfiCode.INVALID_EXCEPTION_VALUE,
   FfiCode.INVALID_FIELD_TYPE_IN_STRUCT,
+  FfiCode.LEAF_CALL_MUST_NOT_RETURN_HANDLE,
+  FfiCode.LEAF_CALL_MUST_NOT_TAKE_HANDLE,
   FfiCode.MISMATCHED_ANNOTATION_ON_STRUCT_FIELD,
   FfiCode.MISSING_ANNOTATION_ON_STRUCT_FIELD,
   FfiCode.MISSING_EXCEPTION_VALUE,

pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart

@@ -21,6 +21,15 @@ class FfiCode extends AnalyzerErrorCode {
           "any annotations.",
       correction: "Try removing the annotation.");
 
+  /**
+   * Parameters:
+   * 0: the name of the argument
+   */
+  static const FfiCode ARGUMENT_MUST_BE_A_CONSTANT = FfiCode(
+      name: 'ARGUMENT_MUST_BE_A_CONSTANT',
+      message: "Argument '{0}' must be a constant.",
+      correction: "Try replacing the value with a literal or const.");
+
   /**
    * Parameters:
    * 0: the name of the struct class
@@ -103,6 +112,22 @@ class FfiCode extends AnalyzerErrorCode {
           "Try using 'int', 'double', 'Array', 'Pointer', or subtype of "
           "'Struct' or 'Union'.");
 
+  /**
+   * No parameters.
+   */
+  static const FfiCode LEAF_CALL_MUST_NOT_RETURN_HANDLE = FfiCode(
+      name: 'LEAF_CALL_MUST_NOT_RETURN_HANDLE',
+      message: "FFI leaf call must not return a Handle.",
+      correction: "Try changing the return type to primitive or struct.");
+
+  /**
+   * No parameters.
+   */
+  static const FfiCode LEAF_CALL_MUST_NOT_TAKE_HANDLE = FfiCode(
+      name: 'LEAF_CALL_MUST_NOT_TAKE_HANDLE',
+      message: "FFI leaf call must not take arguments of type Handle.",
+      correction: "Try changing the argument type to primitive or struct.");
+
   /**
    * No parameters.
    */

pkg/analyzer/lib/error/error.dart

@@ -8,6 +8,7 @@ import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/ast/extensions.dart';
+import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/dart/error/ffi_code.dart';
 
@@ -20,6 +21,7 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
   static const _allocatorExtensionName = 'AllocatorAlloc';
   static const _arrayClassName = 'Array';
   static const _dartFfiLibraryName = 'dart.ffi';
+  static const _isLeafParamName = 'isLeaf';
   static const _opaqueClassName = 'Opaque';
 
   static const List<String> _primitiveIntegerNativeTypes = [
@@ -341,6 +343,26 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
     return false;
   }
 
+  // Get the const bool value of `expr` if it exists.
+  // Return null if it isn't a const bool.
+  bool? _maybeGetBoolConstValue(Expression expr) {
+    if (expr is BooleanLiteral) {
+      return expr.value;
+    } else if (expr is Identifier) {
+      final staticElm = expr.staticElement;
+      if (staticElm is ConstVariableElement) {
+        return staticElm.computeConstantValue()?.toBoolValue();
+      }
+      if (staticElm is PropertyAccessorElementImpl) {
+        final v = staticElm.variable;
+        if (v is ConstVariableElement) {
+          return v.computeConstantValue()?.toBoolValue();
+        }
+      }
+    }
+    return null;
+  }
+
   _PrimitiveDartType _primitiveNativeType(DartType nativeType) {
     if (nativeType is InterfaceType) {
       final element = nativeType.element;
@@ -461,7 +483,9 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
         _errorReporter.reportErrorForNode(
             FfiCode.MUST_BE_A_SUBTYPE, node, [TPrime, F, 'asFunction']);
       }
+      _validateFfiLeafCallUsesNoHandles(node, TPrime, node);
     }
+    _validateIsLeafIsConst(node);
   }
 
   /// Validates that the given [nativeType] is, when native types are converted
@@ -551,6 +575,37 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
     }
   }
 
+  void _validateFfiLeafCallUsesNoHandles(
+      MethodInvocation node, DartType nativeType, AstNode errorNode) {
+    final args = node.argumentList.arguments;
+    if (args.isNotEmpty) {
+      for (final arg in args) {
+        if (arg is NamedExpression) {
+          if (arg.element?.name == _isLeafParamName) {
+            // Handles are ok for regular (non-leaf) calls. Check `isLeaf:true`.
+            final bool? isLeaf = _maybeGetBoolConstValue(arg.expression);
+            if (isLeaf != null && isLeaf) {
+              if (nativeType is FunctionType) {
+                if (_primitiveNativeType(nativeType.returnType) ==
+                    _PrimitiveDartType.handle) {
+                  _errorReporter.reportErrorForNode(
+                      FfiCode.LEAF_CALL_MUST_NOT_RETURN_HANDLE, errorNode);
+                }
+                for (final param in nativeType.normalParameterTypes) {
+                  if (_primitiveNativeType(param) ==
+                      _PrimitiveDartType.handle) {
+                    _errorReporter.reportErrorForNode(
+                        FfiCode.LEAF_CALL_MUST_NOT_TAKE_HANDLE, errorNode);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
   /// Validate that the fields declared by the given [node] meet the
   /// requirements for fields within a struct or union class.
   void _validateFieldsInCompound(FieldDeclaration node) {
@@ -654,6 +709,27 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
     }
   }
 
+  void _validateIsLeafIsConst(MethodInvocation node) {
+    // Ensure `isLeaf` is const as we need the value at compile time to know
+    // which trampoline to generate.
+    final args = node.argumentList.arguments;
+    if (args.isNotEmpty) {
+      for (final arg in args) {
+        if (arg is NamedExpression) {
+          if (arg.element?.name == _isLeafParamName) {
+            if (_maybeGetBoolConstValue(arg.expression) == null) {
+              final AstNode errorNode = node;
+              _errorReporter.reportErrorForNode(
+                  FfiCode.ARGUMENT_MUST_BE_A_CONSTANT,
+                  errorNode,
+                  [_isLeafParamName]);
+            }
+          }
+        }
+      }
+    }
+  }
+
   /// Validate the invocation of the instance method
   /// `DynamicLibrary.lookupFunction<S, F>()`.
   void _validateLookupFunction(MethodInvocation node) {
@@ -678,6 +754,8 @@ class FfiVerifier extends RecursiveAstVisitor<void> {
       _errorReporter.reportErrorForNode(
           FfiCode.MUST_BE_A_SUBTYPE, errorNode, [S, F, 'lookupFunction']);
     }
+    _validateIsLeafIsConst(node);
+    _validateFfiLeafCallUsesNoHandles(node, S, typeArguments![0]);
   }
 
   /// Validate that none of the [annotations] are from `dart:ffi`.

pkg/analyzer/lib/src/dart/error/ffi_code.dart

@@ -620,6 +620,8 @@ class NativeType {
   const NativeType();
 }
 
+class Handle extends NativeType {}
+
 class Void extends NativeType {}
 
 class Int8 extends NativeType {
@@ -674,7 +676,7 @@ final Pointer<Never> nullptr = Pointer.fromAddress(0);
 
 extension NativeFunctionPointer<NF extends Function>
     on Pointer<NativeFunction<NF>> {
-  external DF asFunction<DF extends Function>();
+  external DF asFunction<DF extends Function>({bool isLeaf:false});
 }
 
 class _Compound extends NativeType {}
@@ -689,11 +691,13 @@ class Packed {
   const Packed(this.memberAlignment);
 }
 
-abstract class DynamicLibrary {}
+abstract class DynamicLibrary {
+  external factory DynamicLibrary.open(String name);
+}
 
 extension DynamicLibraryExtension on DynamicLibrary {
   external F lookupFunction<T extends Function, F extends Function>(
-      String symbolName);
+      String symbolName, {bool isLeaf:false});
 }
 
 abstract class NativeFunction<T extends Function> extends NativeType {}

pkg/analyzer/lib/src/generated/ffi_verifier.dart

@@ -0,0 +1,78 @@
+// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/src/dart/error/ffi_code.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../dart/resolution/context_collection_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(ArgumentMustBeAConstantTest);
+  });
+}
+
+@reflectiveTest
+class ArgumentMustBeAConstantTest extends PubPackageResolutionTest {
+  test_AsFunctionIsLeafGlobal() async {
+    await assertErrorsInCode(r'''
+import 'dart:ffi';
+typedef Int8UnOp = Int8 Function(Int8);
+typedef IntUnOp = int Function(int);
+bool isLeaf = false;
+doThings() {
+  Pointer<NativeFunction<Int8UnOp>> p = Pointer.fromAddress(1337);
+  IntUnOp f = p.asFunction(isLeaf:isLeaf);
+  f(8);
+}
+''', [
+      error(FfiCode.ARGUMENT_MUST_BE_A_CONSTANT, 211, 27),
+    ]);
+  }
+
+  test_AsFunctionIsLeafLocal() async {
+    await assertErrorsInCode(r'''
+import 'dart:ffi';
+typedef Int8UnOp = Int8 Function(Int8);
+typedef IntUnOp = int Function(int);
+doThings() {
+  bool isLeaf = false;
+  Pointer<NativeFunction<Int8UnOp>> p = Pointer.fromAddress(1337);
+  IntUnOp f = p.asFunction(isLeaf:isLeaf);
+  f(8);
+}
+''', [
+      error(FfiCode.ARGUMENT_MUST_BE_A_CONSTANT, 213, 27),
+    ]);
+  }
+
+  test_AsFunctionIsLeafParam() async {
+    await assertErrorsInCode(r'''
+import 'dart:ffi';
+typedef Int8UnOp = Int8 Function(Int8);
+typedef IntUnOp = int Function(int);
+doThings(bool isLeaf) {
+  Pointer<NativeFunction<Int8UnOp>> p = Pointer.fromAddress(1337);
+  IntUnOp f = p.asFunction(isLeaf:isLeaf);
+  f(8);
+}
+''', [
+      error(FfiCode.ARGUMENT_MUST_BE_A_CONSTANT, 201, 27),
+    ]);
+  }
+
+  test_LookupFunctionIsLeaf() async {
+    await assertErrorsInCode(r'''
+import 'dart:ffi';
+typedef Int8UnOp = Int8 Function(Int8);
+typedef IntUnOp = int Function(int);
+doThings(bool isLeaf) {
+  DynamicLibrary l = DynamicLibrary.open("my_lib");
+  l.lookupFunction<Int8UnOp, IntUnOp>("timesFour", isLeaf:isLeaf);
+}
+''', [
+      error(FfiCode.ARGUMENT_MUST_BE_A_CONSTANT, 174, 63),
+    ]);
+  }
+}