[VM] Adds leaf call option to FfiNative.

This change essentially exposes `asFunction`'s `isLeaf` in
`@FfiNative`, allowing us to declare FFI Natives as leaf calls.

TEST=Adds tests/ffi/ffi_native_test.dart

Bug: #43889
Change-Id: I2a396fae2ab28d21df282f3afb35fa401485ed52
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/206375
Reviewed-by: Daco Harkes <[email protected]>
Commit-Queue: Clement Skau <[email protected]>

Author: Clement Skau

pkg/vm/lib/transformations/ffi_native.dart

@@ -30,6 +30,7 @@ class FfiNativeTransformer extends Transformer {
   final Class ffiNativeClass;
   final Class nativeFunctionClass;
   final Field ffiNativeNameField;
+  final Field ffiNativeIsLeafField;
   final Field resolverField;
   final Procedure asFunctionProcedure;
   final Procedure fromAddressInternal;
@@ -39,6 +40,8 @@ class FfiNativeTransformer extends Transformer {
         nativeFunctionClass = index.getClass('dart:ffi', 'NativeFunction'),
         ffiNativeNameField =
             index.getField('dart:ffi', 'FfiNative', 'nativeName'),
+        ffiNativeIsLeafField =
+            index.getField('dart:ffi', 'FfiNative', 'isLeaf'),
         resolverField = index.getTopLevelField('dart:ffi', '_ffi_resolver'),
         asFunctionProcedure = index.getProcedure(
             'dart:ffi', 'NativeFunctionPointer', 'asFunction'),
@@ -71,21 +74,23 @@ class FfiNativeTransformer extends Transformer {
   }
 
   // Transform:
-  //   @FfiNative<Double Function(Double)>('Math_sqrt')
+  //   @FfiNative<Double Function(Double)>('Math_sqrt', isLeaf:true)
   //   external double _square_root(double x);
   //
   // Into:
   //   final _@FfiNative__square_root =
   //       Pointer<NativeFunction<Double Function(Double)>>
   //           .fromAddress(_ffi_resolver('dart:math', 'Math_sqrt'))
-  //           .asFunction<double Function(double)>();
+  //           .asFunction<double Function(double)>(isLeaf:true);
   //   double _square_root(double x) => _@FfiNative__square_root(x);
   Statement transformFfiNative(
       Procedure node, InstanceConstant annotationConst) {
     assert(currentLibrary != null);
     final params = node.function.positionalParameters;
     final functionName = annotationConst
         .fieldValues[ffiNativeNameField.getterReference] as StringConstant;
+    final isLeaf = annotationConst
+        .fieldValues[ffiNativeIsLeafField.getterReference] as BoolConstant;
 
     // double Function(double)
     final DartType dartType =
@@ -115,9 +120,12 @@ class FfiNativeTransformer extends Transformer {
         Arguments([resolverInvocation], types: [nativeInterfaceType]));
 
     // NativeFunctionPointer.asFunction
-    //     <Double Function(Double), double Function(double)>(...)
-    final asFunctionInvocation = StaticInvocation(asFunctionProcedure,
-        Arguments([fromAddressInvocation], types: [nativeType, dartType]));
+    //     <Double Function(Double), double Function(double)>(..., isLeaf:true)
+    final asFunctionInvocation = StaticInvocation(
+        asFunctionProcedure,
+        Arguments([fromAddressInvocation],
+            types: [nativeType, dartType],
+            named: [NamedExpression("isLeaf", BoolLiteral(isLeaf.value))]));
 
     // final _@FfiNative__square_root = ...
     final fieldName = Name('_@FfiNative_${node.name.text}', currentLibrary);
@@ -127,7 +135,8 @@ class FfiNativeTransformer extends Transformer {
         isStatic: true,
         isFinal: true,
         fileUri: currentLibrary!.fileUri,
-        getterReference: currentLibraryIndex?.lookupGetterReference(fieldName));
+        getterReference: currentLibraryIndex?.lookupGetterReference(fieldName))
+      ..fileOffset = node.fileOffset;
     currentLibrary!.addField(funcPtrField);
 
     // _@FfiNative__square_root(x)

runtime/bin/ffi_test/ffi_test_functions_vmspecific.cc

@@ -1080,4 +1080,33 @@ DART_EXPORT void ReleaseClosureCallback() {
   Dart_DeletePersistentHandle_DL(closure_to_callback_);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// Functions for testing @FfiNative.
+
+DART_EXPORT Dart_Handle GetRootLibraryUrl() {
+  Dart_Handle root_lib = Dart_RootLibrary();
+  Dart_Handle lib_url = Dart_LibraryUrl(root_lib);
+  ENSURE(!Dart_IsError(lib_url));
+  return lib_url;
+}
+
+intptr_t ReturnIntPtr(intptr_t x) {
+  return x;
+}
+
+static void* FfiNativeResolver(const char* name) {
+  if (strcmp(name, "ReturnIntPtr") == 0) {
+    return reinterpret_cast<void*>(ReturnIntPtr);
+  }
+  // This should be unreachable in tests.
+  ENSURE(false);
+}
+
+DART_EXPORT void SetFfiNativeResolverForTest(Dart_Handle url) {
+  Dart_Handle library = Dart_LookupLibrary(url);
+  ENSURE(!Dart_IsError(library));
+  Dart_Handle result = Dart_SetFfiNativeResolver(library, &FfiNativeResolver);
+  ENSURE(!Dart_IsError(result));
+}
+
 }  // namespace dart

runtime/vm/dart_api_impl_test.cc

@@ -9305,7 +9305,7 @@ static void* FfiNativeResolver(const char* name) {
 TEST_CASE(Dart_SetFfiNativeResolver) {
   const char* kScriptChars = R"(
     import 'dart:ffi';
-    @FfiNative<IntPtr Function(Double)>('EchoInt')
+    @FfiNative<IntPtr Function(Double)>('EchoInt', isLeaf:true)
     external int echoInt(double x);
     main() => echoInt(7.0);
     )";
@@ -9327,7 +9327,7 @@ TEST_CASE(Dart_SetFfiNativeResolver) {
 TEST_CASE(Dart_SetFfiNativeResolver_MissingResolver) {
   const char* kScriptChars = R"(
     import 'dart:ffi';
-    @FfiNative<IntPtr Function(Double)>('EchoInt')
+    @FfiNative<IntPtr Function(Double)>('EchoInt', isLeaf:true)
     external int echoInt(double x);
     main() => echoInt(7.0);
     )";

sdk/lib/ffi/ffi.dart

@@ -806,7 +806,7 @@ abstract class NativeApi {
 ///
 /// Example:
 ///```dart
-/// @FfiNative<Int64 Function(Int64, Int64)>("FfiNative_Sum")
+/// @FfiNative<Int64 Function(Int64, Int64)>("FfiNative_Sum", isLeaf:true)
 /// external int sum(int a, int b);
 ///```
 /// Calling such functions will throw an exception if no resolver
@@ -817,7 +817,8 @@ abstract class NativeApi {
 /// NOTE: This is an experimental feature and may change in the future.
 class FfiNative<T> {
   final String nativeName;
-  const FfiNative(this.nativeName);
+  final bool isLeaf;
+  const FfiNative(this.nativeName, {this.isLeaf: false});
 }
 
 // Bootstrapping native for getting the FFI native C function pointer to look

tests/ffi/ffi_native_test.dart

@@ -0,0 +1,32 @@
+// 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.
+//
+// SharedObjects=ffi_test_functions
+
+import 'dart:ffi';
+
+import 'package:expect/expect.dart';
+
+import 'dylib_utils.dart';
+
+final nativeLib = dlopenPlatformSpecific('ffi_test_functions');
+final getRootLibraryUrl = nativeLib
+    .lookupFunction<Handle Function(), Object Function()>('GetRootLibraryUrl');
+final setFfiNativeResolverForTest = nativeLib
+    .lookupFunction<Void Function(Handle), void Function(Object)>('SetFfiNativeResolverForTest');
+
+@FfiNative<IntPtr Function(IntPtr)>('ReturnIntPtr')
+external int returnIntPtr(int x);
+
+@FfiNative<IntPtr Function(IntPtr)>('ReturnIntPtr', isLeaf: true)
+external int returnIntPtrLeaf(int x);
+
+void main() {
+  // Register test resolver for top-level functions above.
+  final root_lib_url = getRootLibraryUrl();
+  setFfiNativeResolverForTest(root_lib_url);
+
+  Expect.equals(123, returnIntPtr(123));
+  Expect.equals(123, returnIntPtrLeaf(123));
+}