| // Copyright (c) 2019, 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:front_end/src/fasta/codes/fasta_codes.dart' |
| show |
| messageFfiAddressOfMustBeNative, |
| messageFfiAddressPosition, |
| messageFfiAddressReceiver, |
| messageFfiCreateOfStructOrUnion, |
| messageFfiExceptionalReturnNull, |
| messageFfiExpectedConstant, |
| templateFfiDartTypeMismatch, |
| templateFfiNativeCallableListenerReturnVoid, |
| templateFfiExpectedConstantArg, |
| templateFfiExpectedExceptionalReturn, |
| templateFfiExpectedNoExceptionalReturn, |
| templateFfiExtendsOrImplementsSealedClass, |
| templateFfiNotStatic; |
| import 'package:kernel/ast.dart'; |
| import 'package:kernel/class_hierarchy.dart' show ClassHierarchy; |
| import 'package:kernel/clone.dart'; |
| import 'package:kernel/constructor_tearoff_lowering.dart'; |
| import 'package:kernel/core_types.dart'; |
| import 'package:kernel/kernel.dart'; |
| import 'package:kernel/library_index.dart' show LibraryIndex; |
| import 'package:kernel/names.dart'; |
| import 'package:kernel/reference_from_index.dart'; |
| import 'package:kernel/target/targets.dart' show DiagnosticReporter; |
| import 'package:kernel/type_algebra.dart' |
| show FunctionTypeInstantiator, Substitution; |
| import 'package:kernel/type_environment.dart'; |
| |
| import 'common.dart' |
| show FfiStaticTypeError, FfiTransformer, NativeType, FfiTypeCheckDirection; |
| import 'definitions.dart' as definitions; |
| import 'finalizable.dart'; |
| import 'native.dart' as native; |
| import 'native_type_cfe.dart'; |
| |
| /// Checks and replaces calls to dart:ffi compound fields and methods. |
| /// |
| /// To reliably lower calls to methods like `sizeOf` and `Native.addressOf`, |
| /// this requires that the [definitions] and the [native] transformer already |
| /// ran on the libraries to transform. |
| void transformLibraries( |
| Component component, |
| CoreTypes coreTypes, |
| ClassHierarchy hierarchy, |
| List<Library> libraries, |
| DiagnosticReporter diagnosticReporter, |
| ReferenceFromIndex? referenceFromIndex) { |
| final index = LibraryIndex(component, [ |
| "dart:ffi", |
| "dart:_internal", |
| "dart:typed_data", |
| "dart:nativewrappers", |
| "dart:isolate" |
| ]); |
| if (!index.containsLibrary("dart:ffi")) { |
| // TODO: This check doesn't make sense: "dart:ffi" is always loaded/created |
| // for the VM target. |
| // If dart:ffi is not loaded, do not do the transformation. |
| return; |
| } |
| if (index.tryGetClass('dart:ffi', 'NativeFunction') == null) { |
| // If dart:ffi is not loaded (for real): do not do the transformation. |
| return; |
| } |
| final transformer = new _FfiUseSiteTransformer2( |
| index, coreTypes, hierarchy, diagnosticReporter, referenceFromIndex); |
| libraries.forEach(transformer.visitLibrary); |
| } |
| |
| /// Combines [_FfiUseSiteTransformer] and [FinalizableTransformer] into a single |
| /// traversal. |
| /// |
| /// This transformation is not AST-node preserving. [Expression]s and |
| /// [Statement]s can be replaced by other [Expression]s and [Statement]s |
| /// respectively. This means one cannot do `visitX() { super.visitX() as X }`. |
| class _FfiUseSiteTransformer2 extends FfiTransformer |
| with _FfiUseSiteTransformer, FinalizableTransformer { |
| _FfiUseSiteTransformer2( |
| LibraryIndex index, |
| CoreTypes coreTypes, |
| ClassHierarchy hierarchy, |
| DiagnosticReporter diagnosticReporter, |
| ReferenceFromIndex? referenceFromIndex) |
| : super(index, coreTypes, hierarchy, diagnosticReporter, |
| referenceFromIndex); |
| } |
| |
| /// Checks and replaces calls to dart:ffi compound fields and methods. |
| /// |
| /// Designed to be mixed in. Calls super.visitXXX() to visit all nodes (except |
| /// the ones created by this transformation). |
| /// |
| /// This transformation is not AST-node preserving. [Expression]s and |
| /// [Statement]s can be replaced by other [Expression]s and [Statement]s |
| /// respectively. This means one cannot do `visitX() { super.visitX() as X }`. |
| mixin _FfiUseSiteTransformer on FfiTransformer { |
| StaticTypeContext? get staticTypeContext; |
| |
| bool _inFfiTearoff = false; |
| |
| bool get isFfiLibrary => currentLibrary == ffiLibrary; |
| |
| // Used to create private top-level fields with unique names for each |
| // callback. |
| int callbackCount = 0; |
| |
| // Used to create private top-level trampoline methods with unique names |
| // for each call. |
| int callCount = 0; |
| |
| @override |
| TreeNode visitLibrary(Library node) { |
| callbackCount = 0; |
| callCount = 0; |
| return super.visitLibrary(node); |
| } |
| |
| @override |
| visitClass(Class node) { |
| try { |
| _ensureNotExtendsOrImplementsSealedClass(node); |
| return super.visitClass(node); |
| } on FfiStaticTypeError { |
| // It's OK to swallow the exception because the diagnostics issued will |
| // cause compilation to fail. By continuing, we can report more |
| // diagnostics before compilation ends. |
| return super.visitClass(node); |
| } |
| } |
| |
| @override |
| visitConstructorInvocation(ConstructorInvocation node) { |
| if (_inFfiTearoff) { |
| return node; |
| } |
| final target = node.target; |
| if (hierarchy.isSubclassOf(target.enclosingClass, compoundClass) && |
| target.enclosingClass != arrayClass && |
| target.enclosingClass != compoundClass && |
| target.name != Name("#fromTypedDataBase") && |
| target.name != Name("#fromTypedData")) { |
| diagnosticReporter.report(messageFfiCreateOfStructOrUnion, |
| node.fileOffset, 1, node.location?.file); |
| } |
| return super.visitConstructorInvocation(node); |
| } |
| |
| /// Transforms calls to Struct.create and Union.create. |
| /// |
| /// Transforms `create<T>()` into |
| /// |
| /// ``` |
| /// Compound._fromTypedDataBase(Uint8List(sizeOf<T>())) |
| /// ``` |
| /// |
| /// and `create<T>(typedList)` into |
| /// |
| /// ``` |
| /// Compound._fromTypedData(typedList, sizeOf<T>()) |
| /// ``` |
| /// |
| /// in subclasses of `Struct` and `Union`. |
| Expression _transformCompoundCreate(StaticInvocation node) { |
| final positionalArguments = node.arguments.positional; |
| final nativeType = (node.arguments.types.first as InterfaceType); |
| final constructors = nativeType.classNode.constructors; |
| final sizeOfExpression = inlineSizeOf(nativeType)!; |
| if (positionalArguments.isNotEmpty) { |
| // Check length of provided typed data, use checked constructor. |
| return ConstructorInvocation( |
| constructors.firstWhere((c) => c.name == Name("#fromTypedData")), |
| Arguments([ |
| node.arguments.positional.first, |
| (positionalArguments.length >= 2 |
| ? positionalArguments[1] |
| : ConstantExpression(IntConstant(0))), |
| // Length in bytes to check the typedData against. |
| sizeOfExpression, |
| ]), |
| ); |
| } |
| |
| // Correct-size typed data is allocated, use unchecked constructor. |
| return ConstructorInvocation( |
| constructors.firstWhere((c) => c.name == Name("#fromTypedDataBase")), |
| Arguments([ |
| StaticInvocation( |
| uint8ListFactory, |
| Arguments([sizeOfExpression]), |
| ), |
| ConstantExpression(IntConstant(0)), |
| ]), |
| ); |
| } |
| |
| @override |
| visitProcedure(Procedure node) { |
| assert(_inFfiTearoff == false); |
| _inFfiTearoff = ((isFfiLibrary && |
| node.isExtensionMember && |
| (node == allocationTearoff || |
| node == asFunctionTearoff || |
| node == lookupFunctionTearoff || |
| node == abiSpecificIntegerPointerElementAtTearoff || |
| node == structPointerElementAtTearoff || |
| node == unionPointerElementAtTearoff))) || |
| // Dart2wasm uses enabledConstructorTearOffLowerings but these are not |
| // users trying to call constructors. |
| isConstructorTearOffLowering(node); |
| final result = super.visitProcedure(node); |
| _inFfiTearoff = false; |
| return result; |
| } |
| |
| @override |
| TreeNode visitStaticInvocation(StaticInvocation node) { |
| final modifiedExpression = _visitStaticInvocation(node); |
| if (node == modifiedExpression) { |
| return super.visitStaticInvocation(node); |
| } |
| // We've just created this node. We're likely not going to need to transform |
| // this node itself. Visit its sub expressions. |
| return super.defaultExpression(modifiedExpression); |
| } |
| |
| /// Replaces nodes if they match. Does not invoke any super visit. |
| Expression _visitStaticInvocation(StaticInvocation node) { |
| if (_inFfiTearoff) { |
| return node; |
| } |
| final Member target = node.target; |
| try { |
| if (target == abiSpecificIntegerArrayElemAt || |
| target == abiSpecificIntegerArraySetElemAt) { |
| final pointer = node.arguments.positional[0]; |
| final pointerType = |
| pointer.getStaticType(staticTypeContext!) as InterfaceType; |
| ensureNativeTypeValid(pointerType, pointer, |
| allowStructAndUnion: true, allowInlineArray: true); |
| |
| final typeArg = pointerType.typeArguments.single; |
| final nativeTypeCfe = |
| NativeTypeCfe(this, typeArg) as AbiSpecificNativeTypeCfe; |
| |
| final arrayVar = VariableDeclaration("#array", |
| initializer: NullCheck(node.arguments.positional[0]), |
| type: InterfaceType(arrayClass, Nullability.nonNullable), |
| isSynthesized: true) |
| ..fileOffset = node.fileOffset; |
| final indexVar = VariableDeclaration("#index", |
| initializer: NullCheck(node.arguments.positional[1]), |
| type: coreTypes.intNonNullableRawType, |
| isSynthesized: true) |
| ..fileOffset = node.fileOffset; |
| |
| return BlockExpression( |
| Block([ |
| arrayVar, |
| indexVar, |
| ExpressionStatement(InstanceInvocation( |
| InstanceAccessKind.Instance, |
| VariableGet(arrayVar), |
| arrayCheckIndex.name, |
| Arguments([VariableGet(indexVar)]), |
| interfaceTarget: arrayCheckIndex, |
| functionType: arrayCheckIndex.getterType as FunctionType, |
| )), |
| ]), |
| abiSpecificLoadOrStoreExpression( |
| nativeTypeCfe, |
| typedDataBase: getCompoundTypedDataBaseField( |
| VariableGet(arrayVar), |
| node.fileOffset, |
| ), |
| offsetInBytes: getCompoundOffsetInBytesField( |
| VariableGet(arrayVar), |
| node.fileOffset, |
| ), |
| index: VariableGet(indexVar), |
| value: target == abiSpecificIntegerArraySetElemAt |
| ? node.arguments.positional.last |
| : null, |
| fileOffset: node.fileOffset, |
| ), |
| ); |
| } |
| if (target == abiSpecificIntegerPointerGetValue || |
| target == abiSpecificIntegerPointerSetValue || |
| target == abiSpecificIntegerPointerElemAt || |
| target == abiSpecificIntegerPointerSetElemAt) { |
| final pointer = node.arguments.positional[0]; |
| final pointerType = |
| pointer.getStaticType(staticTypeContext!) as InterfaceType; |
| ensureNativeTypeValid(pointerType, pointer, |
| allowStructAndUnion: true, allowInlineArray: true); |
| |
| final typeArg = pointerType.typeArguments.single; |
| final nativeTypeCfe = |
| NativeTypeCfe(this, typeArg) as AbiSpecificNativeTypeCfe; |
| |
| return abiSpecificLoadOrStoreExpression( |
| nativeTypeCfe, |
| typedDataBase: node.arguments.positional[0], |
| index: (target == abiSpecificIntegerPointerElemAt || |
| target == abiSpecificIntegerPointerSetElemAt) |
| ? node.arguments.positional[1] |
| : null, |
| value: (target == abiSpecificIntegerPointerSetValue || |
| target == abiSpecificIntegerPointerSetElemAt) |
| ? node.arguments.positional.last |
| : null, |
| fileOffset: node.fileOffset, |
| ); |
| } |
| if (target == structPointerGetRef || |
| target == structPointerGetElemAt || |
| target == unionPointerGetRef || |
| target == unionPointerGetElemAt) { |
| final DartType nativeType = node.arguments.types[0]; |
| |
| ensureNativeTypeValid(nativeType, node, allowStructAndUnion: true); |
| |
| return _replaceGetRef(node); |
| } else if (target == structPointerSetRef || |
| target == structPointerSetElemAt || |
| target == unionPointerSetRef || |
| target == unionPointerSetElemAt) { |
| final DartType nativeType = node.arguments.types[0]; |
| |
| ensureNativeTypeValid(nativeType, node, allowStructAndUnion: true); |
| |
| return _replaceSetRef(node); |
| } else if (target == abiSpecificIntegerPointerElementAt || |
| target == structPointerElementAt || |
| target == unionPointerElementAt || |
| target == abiSpecificIntegerPointerPlusOperator || |
| target == structPointerPlusOperator || |
| target == unionPointerPlusOperator || |
| target == abiSpecificIntegerPointerMinusOperator || |
| target == structPointerMinusOperator || |
| target == unionPointerMinusOperator) { |
| final pointer = node.arguments.positional[0]; |
| final positiveOffset = node.arguments.positional[1]; |
| final Expression offset; |
| if (target == abiSpecificIntegerPointerMinusOperator || |
| target == structPointerMinusOperator || |
| target == unionPointerMinusOperator) { |
| offset = InstanceInvocation(InstanceAccessKind.Instance, |
| positiveOffset, unaryMinusName, new Arguments([]), |
| interfaceTarget: coreTypes.intUnaryMinus, |
| functionType: coreTypes.intUnaryMinus.getterType as FunctionType); |
| } else { |
| offset = positiveOffset; |
| } |
| final pointerType = |
| pointer.getStaticType(staticTypeContext!) as InterfaceType; |
| ensureNativeTypeValid(pointerType, pointer, |
| allowStructAndUnion: true, allowInlineArray: true); |
| final DartType nativeType = node.arguments.types[0]; |
| |
| ensureNativeTypeValid(nativeType, node, allowStructAndUnion: true); |
| |
| Expression? inlineSizeOf = |
| this.inlineSizeOf(nativeType as InterfaceType); |
| if (inlineSizeOf != null) { |
| // Generates `receiver.offsetBy(inlineSizeOfExpression)`. |
| return InstanceInvocation(InstanceAccessKind.Instance, pointer, |
| offsetByMethod.name, Arguments([multiply(offset, inlineSizeOf)]), |
| interfaceTarget: offsetByMethod, |
| functionType: Substitution.fromInterfaceType(pointerType) |
| .substituteType(offsetByMethod.getterType) as FunctionType); |
| } |
| } else if (target == structArrayElemAt || target == unionArrayElemAt) { |
| final DartType nativeType = node.arguments.types[0]; |
| |
| ensureNativeTypeValid(nativeType, node, allowStructAndUnion: true); |
| |
| return _replaceRefArray(node); |
| } else if (target == arrayArrayElemAt) { |
| final DartType nativeType = node.arguments.types[0]; |
| |
| ensureNativeTypeValid(nativeType, node, |
| allowInlineArray: true, allowStructAndUnion: true); |
| |
| return _replaceArrayArrayElemAt(node); |
| } else if (target == arrayArrayAssignAt) { |
| final DartType nativeType = node.arguments.types[0]; |
| |
| ensureNativeTypeValid(nativeType, node, |
| allowInlineArray: true, allowStructAndUnion: true); |
| |
| return _replaceArrayArrayElemAt(node, setter: true); |
| } else if (target == sizeOfMethod) { |
| final DartType nativeType = node.arguments.types[0]; |
| |
| ensureNativeTypeValid(nativeType, node, |
| allowStructAndUnion: true, allowVoid: true); |
| |
| if (nativeType is InterfaceType) { |
| Expression? inlineSizeOf = this.inlineSizeOf(nativeType); |
| if (inlineSizeOf != null) { |
| return inlineSizeOf; |
| } |
| } |
| } else if (target == lookupFunctionMethod) { |
| final nativeType = InterfaceType(nativeFunctionClass, |
| currentLibrary.nonNullable, [node.arguments.types[0]]); |
| final DartType dartType = node.arguments.types[1]; |
| |
| _ensureIsLeafIsConst(node); |
| final isLeaf = getIsLeafBoolean(node) ?? false; |
| ensureNativeTypeValid(nativeType, node); |
| ensureNativeTypeMatch( |
| FfiTypeCheckDirection.nativeToDart, |
| nativeType, |
| dartType, |
| node, |
| allowHandle: true, // Handle-specific errors emitted below. |
| ); |
| ensureLeafCallDoesNotUseHandles( |
| nativeType, |
| isLeaf, |
| reportErrorOn: node, |
| ); |
| return _replaceLookupFunction(node); |
| } else if (target == asFunctionMethod) { |
| final dartType = node.arguments.types[1]; |
| final InterfaceType nativeType = InterfaceType(nativeFunctionClass, |
| Nullability.nonNullable, [node.arguments.types[0]]); |
| |
| _ensureIsLeafIsConst(node); |
| final isLeaf = getIsLeafBoolean(node) ?? false; |
| |
| ensureNativeTypeValid(nativeType, node); |
| ensureNativeTypeMatch( |
| FfiTypeCheckDirection.nativeToDart, |
| nativeType, |
| dartType, |
| node, |
| allowHandle: true, // Handle-specific errors emitted below. |
| ); |
| ensureLeafCallDoesNotUseHandles( |
| nativeType, |
| isLeaf, |
| reportErrorOn: node, |
| ); |
| final DartType nativeSignature = nativeType.typeArguments[0]; |
| |
| return _replaceAsFunction( |
| functionPointer: node.arguments.positional[0], |
| pointerType: InterfaceType( |
| pointerClass, Nullability.nonNullable, [nativeType]), |
| nativeSignature: nativeSignature, |
| dartSignature: dartType as FunctionType, |
| isLeaf: isLeaf, |
| fileOffset: node.fileOffset, |
| ); |
| } else if (target == fromFunctionMethod) { |
| return _verifyAndReplaceNativeCallableIsolateLocal(node, |
| fromFunction: true); |
| } else if (target == nativeCallableIsolateLocalConstructor) { |
| return _verifyAndReplaceNativeCallableIsolateLocal(node); |
| } else if (target == nativeCallableListenerConstructor) { |
| final DartType nativeType = InterfaceType(nativeFunctionClass, |
| currentLibrary.nonNullable, [node.arguments.types[0]]); |
| final Expression func = node.arguments.positional[0]; |
| final DartType dartType = func.getStaticType(staticTypeContext!); |
| |
| ensureNativeTypeValid(nativeType, node); |
| final ffiFuncType = ensureNativeTypeMatch( |
| FfiTypeCheckDirection.dartToNative, nativeType, dartType, node) |
| as FunctionType; |
| |
| final funcType = dartType as FunctionType; |
| |
| // Check return type. |
| if (ffiFuncType.returnType != VoidType()) { |
| diagnosticReporter.report( |
| templateFfiNativeCallableListenerReturnVoid.withArguments( |
| ffiFuncType.returnType, |
| currentLibrary.isNonNullableByDefault), |
| func.fileOffset, |
| 1, |
| func.location?.file); |
| return node; |
| } |
| |
| final replacement = _replaceNativeCallableListenerConstructor(node); |
| |
| final compoundClasses = funcType.positionalParameters |
| .whereType<InterfaceType>() |
| .map((t) => t.classNode) |
| .where((c) => |
| c.superclass == structClass || c.superclass == unionClass) |
| .toList(); |
| return invokeCompoundConstructors(replacement, compoundClasses); |
| } else if (target == allocateMethod) { |
| final DartType nativeType = node.arguments.types[0]; |
| |
| ensureNativeTypeValid(nativeType, node, |
| allowStructAndUnion: true, allowVoid: true); |
| |
| // Inline the body to get rid of a generic invocation of sizeOf. |
| // TODO(http://dartbug.com/39964): Add `alignmentOf<T>()` call. |
| Expression? sizeInBytes = inlineSizeOf(nativeType as InterfaceType); |
| if (sizeInBytes != null) { |
| if (node.arguments.positional.length == 2) { |
| sizeInBytes = multiply(node.arguments.positional[1], sizeInBytes); |
| } |
| final FunctionType allocateFunctionType = |
| allocatorAllocateMethod.getterType as FunctionType; |
| return InstanceInvocation( |
| InstanceAccessKind.Instance, |
| node.arguments.positional[0], |
| allocatorAllocateMethod.name, |
| Arguments([sizeInBytes], types: node.arguments.types), |
| interfaceTarget: allocatorAllocateMethod, |
| functionType: FunctionTypeInstantiator.instantiate( |
| allocateFunctionType, node.arguments.types)); |
| } |
| } else if (target == structCreate || target == unionCreate) { |
| final nativeType = node.arguments.types.first; |
| ensureNativeTypeValid(nativeType, node, allowStructAndUnion: true); |
| return _transformCompoundCreate(node); |
| } else if (target == nativeAddressOf) { |
| return _replaceNativeAddressOf(node); |
| } else if (addressOfMethods.contains(target)) { |
| // The AST is visited recursively down. Handling of native invocations |
| // will inspect arguments for `<expr>.address` invocations. Any |
| // remaining invocations occur are places where `<expr>.address` is |
| // disallowed, so issue an error. |
| diagnosticReporter.report( |
| messageFfiAddressPosition, node.fileOffset, 1, node.location?.file); |
| } else { |
| final nativeAnnotation = memberGetNativeAnnotation(target); |
| if (nativeAnnotation != null && _isLeaf(nativeAnnotation)) { |
| return _replaceNativeCall(node, nativeAnnotation); |
| } |
| } |
| } on FfiStaticTypeError { |
| // It's OK to swallow the exception because the diagnostics issued will |
| // cause compilation to fail. By continuing, we can report more |
| // diagnostics before compilation ends. |
| } |
| |
| return node; |
| } |
| |
| bool _isLeaf(InstanceConstant native) { |
| return (native.fieldValues[nativeIsLeafField.fieldReference] |
| as BoolConstant) |
| .value; |
| } |
| |
| /// Create Dart function which calls native code. |
| /// |
| /// Adds a native effect invoking a compound constructors if this is used |
| /// as return type. |
| Expression _replaceAsFunction({ |
| required Expression functionPointer, |
| required DartType pointerType, |
| required DartType nativeSignature, |
| required FunctionType dartSignature, |
| required bool isLeaf, |
| required int fileOffset, |
| }) { |
| assert(dartSignature.namedParameters.isEmpty); |
| final functionPointerVarName = '#ffiTarget$callCount'; |
| final closureName = '#ffiClosure$callCount'; |
| ++callCount; |
| |
| final pointerVar = VariableDeclaration(functionPointerVarName, |
| initializer: functionPointer, type: pointerType, isSynthesized: true); |
| |
| final positionalParameters = [ |
| for (int i = 0; i < dartSignature.positionalParameters.length; ++i) |
| VariableDeclaration( |
| 'arg${i + 1}', |
| type: dartSignature.positionalParameters[i], |
| ) |
| ]; |
| |
| final closure = FunctionDeclaration( |
| VariableDeclaration(closureName, |
| type: dartSignature, isSynthesized: true) |
| ..addAnnotation(ConstantExpression( |
| InstanceConstant(coreTypes.pragmaClass.reference, [], { |
| coreTypes.pragmaName.fieldReference: |
| StringConstant('vm:ffi:call-closure'), |
| coreTypes.pragmaOptions.fieldReference: InstanceConstant( |
| ffiCallClass.reference, |
| [nativeSignature], |
| { |
| ffiCallIsLeafField.fieldReference: BoolConstant(isLeaf), |
| }, |
| ), |
| }))), |
| FunctionNode( |
| Block([ |
| for (final param in positionalParameters) |
| ExpressionStatement(StaticInvocation( |
| nativeEffectMethod, Arguments([VariableGet(param)]))), |
| ReturnStatement(StaticInvocation( |
| ffiCallMethod, |
| Arguments([ |
| VariableGet(pointerVar), |
| ], types: [ |
| dartSignature.returnType, |
| ])) |
| ..fileOffset = fileOffset), |
| ]), |
| positionalParameters: positionalParameters, |
| requiredParameterCount: dartSignature.requiredParameterCount, |
| returnType: dartSignature.returnType) |
| ..fileOffset = fileOffset) |
| ..fileOffset = fileOffset; |
| |
| final result = BlockExpression( |
| Block([ |
| pointerVar, |
| closure, |
| ]), |
| VariableGet(closure.variable)); |
| |
| final possibleCompoundReturn = findCompoundReturnType(dartSignature); |
| if (possibleCompoundReturn != null) { |
| return invokeCompoundConstructor(result, possibleCompoundReturn); |
| } |
| |
| return result; |
| } |
| |
| Expression invokeCompoundConstructors( |
| Expression nestedExpression, List<Class> compoundClasses) => |
| compoundClasses |
| .distinct() |
| .fold(nestedExpression, invokeCompoundConstructor); |
| |
| // We need to replace calls to 'DynamicLibrary.lookupFunction' with explicit |
| // Kernel, because we cannot have a generic call to 'asFunction' in its body. |
| // |
| // Above, in 'visitStaticInvocation', we ensure that the type arguments to |
| // 'lookupFunction' are constants, so by inlining the call to 'asFunction' at |
| // the call-site, we ensure that there are no generic calls to 'asFunction'. |
| Expression _replaceLookupFunction(StaticInvocation node) { |
| final DartType nativeSignature = node.arguments.types[0]; |
| final DartType dartSignature = node.arguments.types[1]; |
| |
| final List<DartType> lookupTypeArgs = [ |
| InterfaceType( |
| nativeFunctionClass, currentLibrary.nonNullable, [nativeSignature]) |
| ]; |
| final Arguments lookupArgs = |
| Arguments([node.arguments.positional[1]], types: lookupTypeArgs); |
| final FunctionType lookupFunctionType = |
| libraryLookupMethod.getterType as FunctionType; |
| |
| final lookupResult = InstanceInvocation(InstanceAccessKind.Instance, |
| node.arguments.positional[0], libraryLookupMethod.name, lookupArgs, |
| interfaceTarget: libraryLookupMethod, |
| functionType: FunctionTypeInstantiator.instantiate( |
| lookupFunctionType, lookupTypeArgs)); |
| |
| final isLeaf = getIsLeafBoolean(node) ?? false; |
| |
| return _replaceAsFunction( |
| functionPointer: lookupResult, |
| pointerType: lookupResult.functionType.returnType, |
| nativeSignature: nativeSignature, |
| dartSignature: dartSignature as FunctionType, |
| isLeaf: isLeaf, |
| fileOffset: node.fileOffset, |
| ); |
| } |
| |
| // We need to rewrite calls to 'fromFunction' into two calls, representing the |
| // compile-time and run-time aspects of creating the closure: |
| // |
| // final dynamic _#ffiCallback0 = Pointer.fromFunction<T>(f, e) => |
| // _createNativeCallableIsolateLocal<NativeFunction<T>>( |
| // _nativeCallbackFunction<T>(f, e), null, false); |
| // |
| // ... _#ffiCallback0 ... |
| // |
| // We must implement this as a Kernel rewrite because <T> must be a |
| // compile-time constant to any invocation of '_nativeCallbackFunction'. |
| // |
| // Creating this closure requires a runtime call, so we save the result in a |
| // synthetic top-level field to avoid recomputing it. |
| Expression _replaceFromFunction( |
| StaticInvocation node, Expression exceptionalReturn) { |
| final nativeFunctionType = InterfaceType( |
| nativeFunctionClass, currentLibrary.nonNullable, node.arguments.types); |
| var name = Name("_#ffiCallback${callbackCount++}", currentLibrary); |
| var getterReference = currentLibraryIndex?.lookupGetterReference(name); |
| final Field field = Field.immutable(name, |
| type: InterfaceType( |
| pointerClass, currentLibrary.nonNullable, [nativeFunctionType]), |
| initializer: StaticInvocation( |
| createNativeCallableIsolateLocalProcedure, |
| Arguments([ |
| StaticInvocation( |
| nativeCallbackFunctionProcedure, |
| Arguments([ |
| node.arguments.positional[0], |
| exceptionalReturn, |
| ], types: node.arguments.types)), |
| NullLiteral(), |
| BoolLiteral(false), |
| ], types: [ |
| nativeFunctionType |
| ])), |
| isStatic: true, |
| isFinal: true, |
| fileUri: currentLibrary.fileUri, |
| getterReference: getterReference) |
| ..fileOffset = node.fileOffset; |
| currentLibrary.addField(field); |
| return StaticGet(field); |
| } |
| |
| // NativeCallable<T>.isolateLocal(target, exceptionalReturn) calls become: |
| // isStaticFunction is false: |
| // _NativeCallableIsolateLocal<T>( |
| // _createNativeCallableIsolateLocal<NativeFunction<T>>( |
| // _nativeIsolateLocalCallbackFunction<T>(exceptionalReturn), |
| // target, |
| // true)); |
| // isStaticFunction is true: |
| // _NativeCallableIsolateLocal<T>( |
| // _createNativeCallableIsolateLocal<NativeFunction<T>>( |
| // _nativeCallbackFunction<T>(target, exceptionalReturn), |
| // null, |
| // true); |
| Expression _replaceNativeCallableIsolateLocalConstructor( |
| StaticInvocation node, |
| Expression exceptionalReturn, |
| bool isStaticFunction) { |
| final nativeFunctionType = InterfaceType( |
| nativeFunctionClass, currentLibrary.nonNullable, node.arguments.types); |
| final target = node.arguments.positional[0]; |
| late StaticInvocation pointerValue; |
| if (isStaticFunction) { |
| pointerValue = StaticInvocation( |
| createNativeCallableIsolateLocalProcedure, |
| Arguments([ |
| StaticInvocation( |
| nativeCallbackFunctionProcedure, |
| Arguments([ |
| target, |
| exceptionalReturn, |
| ], types: node.arguments.types)), |
| NullLiteral(), |
| BoolLiteral(true), |
| ], types: [ |
| nativeFunctionType, |
| ])); |
| } else { |
| pointerValue = StaticInvocation( |
| createNativeCallableIsolateLocalProcedure, |
| Arguments([ |
| StaticInvocation(nativeIsolateLocalCallbackFunctionProcedure, |
| Arguments([exceptionalReturn], types: node.arguments.types)), |
| target, |
| BoolLiteral(true), |
| ], types: [ |
| nativeFunctionType, |
| ])); |
| } |
| return ConstructorInvocation(nativeCallablePrivateIsolateLocalConstructor, |
| Arguments([pointerValue], types: node.arguments.types)); |
| } |
| |
| // NativeCallable<T>.listener(target) calls become: |
| // void _handler(List args) => target(args[0], args[1], ...) |
| // final _callback = _NativeCallableListener<T>(_handler, debugName); |
| // _callback._pointer = _createNativeCallableListener<NativeFunction<T>>( |
| // _nativeAsyncCallbackFunction<T>(), _callback._rawPort); |
| // expression result: _callback; |
| Expression _replaceNativeCallableListenerConstructor(StaticInvocation node) { |
| final nativeFunctionType = InterfaceType( |
| nativeFunctionClass, currentLibrary.nonNullable, node.arguments.types); |
| final listType = InterfaceType(listClass, currentLibrary.nonNullable); |
| final nativeCallableType = InterfaceType( |
| nativeCallableClass, currentLibrary.nonNullable, node.arguments.types); |
| final targetType = node.arguments.types[0] as FunctionType; |
| |
| // void _handler(List args) => target(args[0], args[1], ...) |
| final args = VariableDeclaration('args', type: listType, isFinal: true) |
| ..fileOffset = node.fileOffset; |
| final targetArgs = <Expression>[]; |
| for (int i = 0; i < targetType.positionalParameters.length; ++i) { |
| targetArgs.add(InstanceInvocation(InstanceAccessKind.Instance, |
| VariableGet(args), listElementAt.name, Arguments([IntLiteral(i)]), |
| interfaceTarget: listElementAt, |
| functionType: Substitution.fromInterfaceType(listType) |
| .substituteType(listElementAt.getterType) as FunctionType)); |
| } |
| final target = node.arguments.positional[0]; |
| final handlerBody = ExpressionStatement(FunctionInvocation( |
| FunctionAccessKind.FunctionType, |
| target, |
| Arguments(targetArgs), |
| functionType: targetType, |
| )); |
| final handler = FunctionNode(handlerBody, |
| positionalParameters: [args], returnType: VoidType()) |
| ..fileOffset = node.fileOffset; |
| |
| // final _callback = NativeCallable<T>._listener(_handler, debugName); |
| final nativeCallable = VariableDeclaration.forValue( |
| ConstructorInvocation( |
| nativeCallablePrivateListenerConstructor, |
| Arguments([ |
| FunctionExpression(handler), |
| StringLiteral('NativeCallable($target)'), |
| ], types: [ |
| targetType, |
| ])), |
| type: nativeCallableType, |
| isFinal: true) |
| ..fileOffset = node.fileOffset; |
| |
| // _callback._pointer = _createNativeCallableListener<NativeFunction<T>>( |
| // _nativeAsyncCallbackFunction<T>(), _callback._rawPort); |
| final pointerValue = StaticInvocation( |
| createNativeCallableListenerProcedure, |
| Arguments([ |
| StaticInvocation(nativeAsyncCallbackFunctionProcedure, |
| Arguments([], types: [targetType])), |
| InstanceGet(InstanceAccessKind.Instance, VariableGet(nativeCallable), |
| nativeCallablePortField.name, |
| interfaceTarget: nativeCallablePortField, |
| resultType: nativeCallablePortField.getterType), |
| ], types: [ |
| nativeFunctionType, |
| ])); |
| final pointerSetter = ExpressionStatement(InstanceSet( |
| InstanceAccessKind.Instance, |
| VariableGet(nativeCallable), |
| nativeCallablePointerField.name, |
| pointerValue, |
| interfaceTarget: nativeCallablePointerField, |
| )); |
| |
| // expression result: _callback; |
| return BlockExpression( |
| Block([ |
| nativeCallable, |
| pointerSetter, |
| ]), |
| VariableGet(nativeCallable)); |
| } |
| |
| Expression _verifyAndReplaceNativeCallableIsolateLocal(StaticInvocation node, |
| {bool fromFunction = false}) { |
| final DartType nativeType = InterfaceType(nativeFunctionClass, |
| currentLibrary.nonNullable, [node.arguments.types[0]]); |
| final Expression func = node.arguments.positional[0]; |
| final DartType dartType = func.getStaticType(staticTypeContext!); |
| |
| final isStaticFunction = _isStaticFunction(func); |
| if (fromFunction && !isStaticFunction) { |
| diagnosticReporter.report( |
| templateFfiNotStatic.withArguments(fromFunctionMethod.name.text), |
| func.fileOffset, |
| 1, |
| func.location?.file); |
| return node; |
| } |
| |
| ensureNativeTypeValid(nativeType, node); |
| final ffiFuncType = ensureNativeTypeMatch( |
| FfiTypeCheckDirection.dartToNative, |
| nativeType, |
| dartType, |
| node, |
| ) as FunctionType; |
| |
| final funcType = dartType as FunctionType; |
| |
| // Check `exceptionalReturn`'s type. |
| final Class expectedReturnClass = |
| ((node.arguments.types[0] as FunctionType).returnType as InterfaceType) |
| .classNode; |
| final NativeType? expectedReturn = getType(expectedReturnClass); |
| |
| Expression exceptionalReturn = NullLiteral(); |
| bool hasExceptionalReturn = false; |
| if (fromFunction) { |
| if (node.arguments.positional.length > 1) { |
| exceptionalReturn = node.arguments.positional[1]; |
| hasExceptionalReturn = true; |
| } |
| } else { |
| if (node.arguments.named.isNotEmpty) { |
| exceptionalReturn = node.arguments.named[0].value; |
| hasExceptionalReturn = true; |
| } |
| } |
| |
| if (expectedReturn == NativeType.kVoid || |
| expectedReturn == NativeType.kPointer || |
| expectedReturn == NativeType.kHandle || |
| expectedReturnClass.superclass == structClass || |
| expectedReturnClass.superclass == unionClass) { |
| if (hasExceptionalReturn) { |
| diagnosticReporter.report( |
| templateFfiExpectedNoExceptionalReturn.withArguments( |
| ffiFuncType.returnType, currentLibrary.isNonNullableByDefault), |
| node.fileOffset, |
| 1, |
| node.location?.file); |
| return node; |
| } |
| } else { |
| // The exceptional return value is not optional for other return types. |
| if (!hasExceptionalReturn) { |
| diagnosticReporter.report( |
| templateFfiExpectedExceptionalReturn.withArguments( |
| ffiFuncType.returnType, currentLibrary.isNonNullableByDefault), |
| node.fileOffset, |
| 1, |
| node.location?.file); |
| return node; |
| } |
| |
| // The exceptional return value must be a constant so that it can be |
| // referenced by precompiled trampoline's object pool. |
| if (exceptionalReturn is! BasicLiteral && |
| !(exceptionalReturn is ConstantExpression && |
| exceptionalReturn.constant is PrimitiveConstant)) { |
| diagnosticReporter.report(messageFfiExpectedConstant, node.fileOffset, |
| 1, node.location?.file); |
| return node; |
| } |
| |
| // Moreover it may not be null. |
| if (exceptionalReturn is NullLiteral || |
| (exceptionalReturn is ConstantExpression && |
| exceptionalReturn.constant is NullConstant)) { |
| diagnosticReporter.report(messageFfiExceptionalReturnNull, |
| node.fileOffset, 1, node.location?.file); |
| return node; |
| } |
| |
| final DartType returnType = |
| exceptionalReturn.getStaticType(staticTypeContext!); |
| |
| if (!env.isSubtypeOf(returnType, funcType.returnType, |
| SubtypeCheckMode.ignoringNullabilities)) { |
| diagnosticReporter.report( |
| templateFfiDartTypeMismatch.withArguments(returnType, |
| funcType.returnType, currentLibrary.isNonNullableByDefault), |
| exceptionalReturn.fileOffset, |
| 1, |
| exceptionalReturn.location?.file); |
| return node; |
| } |
| } |
| |
| final replacement = fromFunction |
| ? _replaceFromFunction(node, exceptionalReturn) |
| : _replaceNativeCallableIsolateLocalConstructor( |
| node, exceptionalReturn, isStaticFunction); |
| |
| final compoundClasses = funcType.positionalParameters |
| .whereType<InterfaceType>() |
| .map((t) => t.classNode) |
| .where((c) => c.superclass == structClass || c.superclass == unionClass) |
| .toList(); |
| return invokeCompoundConstructors(replacement, compoundClasses); |
| } |
| |
| Expression _replaceGetRef(StaticInvocation node) { |
| final dartType = node.arguments.types[0]; |
| final clazz = (dartType as InterfaceType).classNode; |
| final referencedStruct = ReferencedCompoundSubtypeCfe(clazz); |
| |
| Expression pointer = NullCheck(node.arguments.positional[0]); |
| if (node.arguments.positional.length == 2) { |
| pointer = InstanceInvocation( |
| InstanceAccessKind.Instance, |
| pointer, |
| offsetByMethod.name, |
| Arguments([ |
| multiply(node.arguments.positional[1], inlineSizeOf(dartType)!) |
| ]), |
| interfaceTarget: offsetByMethod, |
| functionType: |
| Substitution.fromPairs(pointerClass.typeParameters, [dartType]) |
| .substituteType(offsetByMethod.getterType) as FunctionType); |
| } |
| |
| return referencedStruct.generateLoad( |
| dartType: dartType, |
| transformer: this, |
| typedDataBase: pointer, |
| offsetInBytes: ConstantExpression(IntConstant(0)), |
| fileOffset: node.fileOffset, |
| ); |
| } |
| |
| /// Replaces a `.ref=` or `[]=` on a compound pointer extension with a mem |
| /// copy call. |
| Expression _replaceSetRef(StaticInvocation node) { |
| final target = node.arguments.positional[0]; // Receiver of extension |
| final referencedStruct = ReferencedCompoundSubtypeCfe( |
| (node.arguments.types[0] as InterfaceType).classNode); |
| |
| final Expression sourceStruct, targetOffset; |
| final DartType sourceStructType; |
| |
| if (node.arguments.positional.length == 3) { |
| // []= call, args are (receiver, index, source) |
| sourceStruct = node.arguments.positional[2]; |
| sourceStructType = node.arguments.types[0]; |
| targetOffset = multiply(node.arguments.positional[1], |
| inlineSizeOf(node.arguments.types[0] as InterfaceType)!); |
| } else { |
| // .ref= call, args are (receiver, source) |
| sourceStruct = node.arguments.positional[1]; |
| sourceStructType = node.arguments.types[0]; |
| targetOffset = ConstantExpression(IntConstant(0)); |
| } |
| |
| final sourceVar = VariableDeclaration( |
| "#source", |
| initializer: sourceStruct, |
| type: sourceStructType, |
| isSynthesized: true, |
| )..fileOffset = node.fileOffset; |
| |
| return BlockExpression( |
| Block([sourceVar]), |
| referencedStruct.generateStore( |
| sourceVar, |
| dartType: node.arguments.types[0], |
| offsetInBytes: targetOffset, |
| typedDataBase: target, |
| transformer: this, |
| fileOffset: node.fileOffset, |
| ), |
| ); |
| } |
| |
| Expression _replaceRefArray(StaticInvocation node) { |
| final dartType = node.arguments.types[0]; |
| final clazz = (dartType as InterfaceType).classNode; |
| final constructor = clazz.constructors |
| .firstWhere((c) => c.name == Name("#fromTypedDataBase")); |
| |
| final arrayVar = VariableDeclaration("#array", |
| initializer: NullCheck(node.arguments.positional[0]), |
| type: InterfaceType(arrayClass, Nullability.nonNullable), |
| isSynthesized: true) |
| ..fileOffset = node.fileOffset; |
| final indexVar = VariableDeclaration("#index", |
| initializer: NullCheck(node.arguments.positional[1]), |
| type: coreTypes.intNonNullableRawType, |
| isSynthesized: true) |
| ..fileOffset = node.fileOffset; |
| |
| return BlockExpression( |
| Block([ |
| arrayVar, |
| indexVar, |
| ExpressionStatement(InstanceInvocation( |
| InstanceAccessKind.Instance, |
| VariableGet(arrayVar), |
| arrayCheckIndex.name, |
| Arguments([VariableGet(indexVar)]), |
| interfaceTarget: arrayCheckIndex, |
| functionType: arrayCheckIndex.getterType as FunctionType, |
| )), |
| ]), |
| ConstructorInvocation( |
| constructor, |
| Arguments([ |
| getCompoundTypedDataBaseField( |
| VariableGet(arrayVar), |
| node.fileOffset, |
| ), |
| add( |
| getCompoundOffsetInBytesField( |
| VariableGet(arrayVar), |
| node.fileOffset, |
| ), |
| multiply(VariableGet(indexVar), inlineSizeOf(dartType)!), |
| ), |
| ]), |
| ), |
| ); |
| } |
| |
| /// Generates an expression that returns a new `Array<dartType>`. |
| /// |
| /// Sample input getter: |
| /// ``` |
| /// this<Array<T>>[index] |
| /// ``` |
| /// |
| /// Sample output getter: |
| /// |
| /// ``` |
| /// Array #array = this!; |
| /// int #index = index!; |
| /// #array._checkIndex(#index); |
| /// int #singleElementSize = inlineSizeOf<innermost(T)>(); |
| /// int #elementSize = #array.nestedDimensionsFlattened * #singleElementSize; |
| /// int #offset = #elementSize * #index; |
| /// |
| /// new Array<T>._( |
| /// #array._typedDataBase, |
| /// #offset, |
| /// #array.nestedDimensionsFirst, |
| /// #array.nestedDimensionsRest |
| /// ) |
| /// ``` |
| /// |
| /// Sample input setter: |
| /// ``` |
| /// this<Array<T>>[index] = value |
| /// ``` |
| /// |
| /// Sample output setter: |
| /// |
| /// ``` |
| /// Array #array = this!; |
| /// int #index = index!; |
| /// #array._checkIndex(#index); |
| /// int #singleElementSize = inlineSizeOf<innermost(T)>(); |
| /// int #elementSize = #array.nestedDimensionsFlattened * #singleElementSize; |
| /// int #offset = #elementSize * #index; |
| /// |
| /// _memCopy( |
| /// #array._typedDataBase, #offset, value._typedDataBase, 0, #elementSize) |
| /// ``` |
| Expression _replaceArrayArrayElemAt(StaticInvocation node, |
| {bool setter = false}) { |
| final dartType = node.arguments.types[0]; |
| final elementType = arraySingleElementType(dartType as InterfaceType); |
| |
| final arrayVar = VariableDeclaration("#array", |
| initializer: NullCheck(node.arguments.positional[0]), |
| type: InterfaceType(arrayClass, Nullability.nonNullable), |
| isSynthesized: true) |
| ..fileOffset = node.fileOffset; |
| final indexVar = VariableDeclaration("#index", |
| initializer: NullCheck(node.arguments.positional[1]), |
| type: coreTypes.intNonNullableRawType, |
| isSynthesized: true) |
| ..fileOffset = node.fileOffset; |
| final singleElementSizeVar = VariableDeclaration("#singleElementSize", |
| initializer: inlineSizeOf(elementType as InterfaceType), |
| type: coreTypes.intNonNullableRawType, |
| isSynthesized: true) |
| ..fileOffset = node.fileOffset; |
| final elementSizeVar = VariableDeclaration("#elementSize", |
| initializer: multiply( |
| VariableGet(singleElementSizeVar), |
| InstanceGet(InstanceAccessKind.Instance, VariableGet(arrayVar), |
| arrayNestedDimensionsFlattened.name, |
| interfaceTarget: arrayNestedDimensionsFlattened, |
| resultType: arrayNestedDimensionsFlattened.getterType)), |
| type: coreTypes.intNonNullableRawType, |
| isSynthesized: true) |
| ..fileOffset = node.fileOffset; |
| final offsetVar = VariableDeclaration("#offset", |
| initializer: |
| multiply(VariableGet(elementSizeVar), VariableGet(indexVar)), |
| type: coreTypes.intNonNullableRawType, |
| isSynthesized: true) |
| ..fileOffset = node.fileOffset; |
| |
| final checkIndexAndLocalVars = [ |
| arrayVar, |
| indexVar, |
| ExpressionStatement(InstanceInvocation( |
| InstanceAccessKind.Instance, |
| VariableGet(arrayVar), |
| arrayCheckIndex.name, |
| Arguments([VariableGet(indexVar)]), |
| interfaceTarget: arrayCheckIndex, |
| functionType: arrayCheckIndex.getterType as FunctionType, |
| )), |
| singleElementSizeVar, |
| elementSizeVar, |
| offsetVar, |
| ]; |
| |
| if (!setter) { |
| // `[]` |
| return BlockExpression( |
| Block(checkIndexAndLocalVars), |
| ConstructorInvocation( |
| arrayConstructor, |
| Arguments([ |
| getCompoundTypedDataBaseField( |
| VariableGet(arrayVar), |
| node.fileOffset, |
| ), |
| add( |
| getCompoundOffsetInBytesField( |
| VariableGet(arrayVar), |
| node.fileOffset, |
| ), |
| VariableGet(offsetVar), |
| ), |
| InstanceGet(InstanceAccessKind.Instance, VariableGet(arrayVar), |
| arrayNestedDimensionsFirst.name, |
| interfaceTarget: arrayNestedDimensionsFirst, |
| resultType: arrayNestedDimensionsFirst.getterType), |
| InstanceGet(InstanceAccessKind.Instance, VariableGet(arrayVar), |
| arrayNestedDimensionsRest.name, |
| interfaceTarget: arrayNestedDimensionsRest, |
| resultType: arrayNestedDimensionsRest.getterType) |
| ], types: [ |
| dartType |
| ]))); |
| } |
| |
| // `[]=` |
| final valueVar = VariableDeclaration( |
| "#value", |
| initializer: NullCheck(node.arguments.positional[2]), |
| type: InterfaceType(arrayClass, Nullability.nonNullable), |
| isSynthesized: true, |
| )..fileOffset = node.fileOffset; |
| return BlockExpression( |
| Block([ |
| ...checkIndexAndLocalVars, |
| valueVar, |
| ]), |
| StaticInvocation( |
| memCopy, |
| Arguments([ |
| getCompoundTypedDataBaseField( |
| VariableGet(arrayVar), |
| node.fileOffset, |
| ), |
| add( |
| getCompoundOffsetInBytesField( |
| VariableGet(arrayVar), |
| node.fileOffset, |
| ), |
| VariableGet(offsetVar), |
| ), |
| getCompoundTypedDataBaseField( |
| VariableGet(valueVar), |
| node.fileOffset, |
| ), |
| getCompoundOffsetInBytesField( |
| VariableGet(valueVar), |
| node.fileOffset, |
| ), |
| VariableGet(elementSizeVar), |
| ])) |
| ..fileOffset = node.fileOffset); |
| } |
| |
| bool _isStaticFunction(Expression node) => |
| (node is StaticGet && node.target is Procedure) || |
| (node is ConstantExpression && node.constant is StaticTearOffConstant); |
| |
| /// Returns the class that should not be implemented or extended. |
| /// |
| /// If the superclass is not sealed, returns `null`. |
| Class? _extendsOrImplementsSealedClass(Class klass) { |
| // Classes in dart:ffi themselves can extend FFI classes. |
| if (klass == arrayClass || |
| klass == arraySizeClass || |
| klass == compoundClass || |
| klass == opaqueClass || |
| klass == structClass || |
| klass == unionClass || |
| klass == abiSpecificIntegerClass || |
| klass == varArgsClass || |
| classNativeTypes[klass] != null) { |
| return null; |
| } |
| |
| // The Opaque and Struct classes can be extended, but subclasses |
| // cannot be (nor implemented). |
| final onlyDirectExtendsClasses = [ |
| opaqueClass, |
| structClass, |
| unionClass, |
| abiSpecificIntegerClass, |
| ]; |
| final superClass = klass.superclass; |
| for (final onlyDirectExtendsClass in onlyDirectExtendsClasses) { |
| if (hierarchy.isSubInterfaceOf(klass, onlyDirectExtendsClass)) { |
| if (superClass == onlyDirectExtendsClass) { |
| // Directly extending is fine. |
| return null; |
| } else { |
| return superClass; |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| void _ensureNotExtendsOrImplementsSealedClass(Class klass) { |
| final Class? extended = _extendsOrImplementsSealedClass(klass); |
| if (extended != null) { |
| diagnosticReporter.report( |
| templateFfiExtendsOrImplementsSealedClass |
| .withArguments(extended.name), |
| klass.fileOffset, |
| 1, |
| klass.location?.file); |
| throw FfiStaticTypeError(); |
| } |
| } |
| |
| void _ensureIsLeafIsConst(StaticInvocation node) { |
| final isLeaf = getIsLeafBoolean(node); |
| if (isLeaf == null) { |
| diagnosticReporter.report( |
| templateFfiExpectedConstantArg.withArguments('isLeaf'), |
| node.fileOffset, |
| 1, |
| node.location?.file); |
| // Throw so we don't get another error about not replacing |
| // `lookupFunction`, which will shadow the above error. |
| throw FfiStaticTypeError(); |
| } |
| } |
| |
| /// Replaces calls to `Native.addressOf(x)` by looking up the `@Native` |
| /// annotation of `x` and rewriting the expression to use |
| /// `_addressOf(annotation)`, which is implemented in the VM. |
| /// |
| /// By implementing this in the VM, we can re-use the implementation used to |
| /// lookup addresses for `@Native` invocations. We could also replace the |
| /// call with an invocation to `Native._ffi_resolver_function` and wrap the |
| /// result in a `Pointer`. To support static linking of native functions in |
| /// the future, having the unresolved symbol in the assembly generated for |
| /// each call site in the VM will be necessary. So we're already doing this |
| /// in the VM today. |
| /// |
| /// The transformation works by looking up the resolved `@Native` annotation |
| /// left by the native transformer in a pragma. Looking for a `@Native` |
| /// annotation on the argument wouldn't work because it's removed by the |
| /// native transformer and because it requires context from the library to |
| /// resolve the asset id. |
| StaticInvocation _replaceNativeAddressOf(StaticInvocation node) { |
| final arg = node.arguments.positional.single; |
| final nativeType = node.arguments.types.single; |
| |
| final potentiallyNativeTarget = switch (arg) { |
| ConstantExpression(constant: StaticTearOffConstant method) => |
| method.target, |
| StaticGet(:var targetReference) => targetReference.asMember, |
| _ => null, |
| }; |
| Constant? nativeAnnotation = |
| memberGetNativeAnnotation(potentiallyNativeTarget); |
| |
| if (nativeAnnotation == null) { |
| diagnosticReporter.report(messageFfiAddressOfMustBeNative, arg.fileOffset, |
| 1, node.location?.file); |
| return node; |
| } |
| |
| ensureNativeTypeValid(nativeType, node, |
| allowStructAndUnion: true, allowInlineArray: true); |
| ensureNativeTypeMatch(FfiTypeCheckDirection.nativeToDart, nativeType, |
| arg.getStaticType(staticTypeContext!), node, |
| allowArray: true); |
| |
| return StaticInvocation( |
| nativePrivateAddressOf, |
| Arguments([ConstantExpression(nativeAnnotation)], types: [nativeType]), |
| )..fileOffset = arg.fileOffset; |
| } |
| |
| InstanceConstant? memberGetNativeAnnotation(Member? member) { |
| if (member == null) { |
| return null; |
| } |
| for (final annotation in member.annotations) { |
| if (annotation |
| case ConstantExpression(constant: final InstanceConstant c)) { |
| if (c.classNode == coreTypes.pragmaClass) { |
| final name = c.fieldValues[coreTypes.pragmaName.fieldReference]; |
| if (name is StringConstant && |
| name.value == native.FfiNativeTransformer.nativeMarker) { |
| return c.fieldValues[coreTypes.pragmaOptions.fieldReference] |
| as InstanceConstant; |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| StaticInvocation _replaceNativeCall( |
| StaticInvocation node, |
| InstanceConstant targetNativeAnnotation, |
| ) { |
| final target = node.target; |
| if (targetNativeAnnotation.typeArguments.length != 1) { |
| return node; |
| } |
| final annotationType = targetNativeAnnotation.typeArguments.single; |
| if (annotationType is! FunctionType) { |
| return node; |
| } |
| final parameterTypes = [ |
| for (final varDecl in target.function.positionalParameters) varDecl.type, |
| ]; |
| final numParams = parameterTypes.length; |
| String methodPostfix = ''; |
| final newArguments = <Expression>[]; |
| final newParameters = <VariableDeclaration>[]; |
| bool isTransformed = false; |
| for (int i = 0; i < numParams; i++) { |
| final parameter = target.function.positionalParameters[i]; |
| final parameterType = parameterTypes[i]; |
| final argument = node.arguments.positional[i]; |
| final ( |
| postFix, |
| newType, |
| newArgument, |
| ) = _replaceNativeCallParameterAndArgument( |
| parameter, |
| parameterType, |
| argument, |
| node.fileOffset, |
| ); |
| methodPostfix += postFix; |
| if (postFix == 'C' || postFix == 'E' || postFix == 'T') { |
| isTransformed = true; |
| } |
| newParameters.add(VariableDeclaration( |
| parameter.name, |
| type: newType, |
| )); |
| newArguments.add(newArgument); |
| } |
| |
| if (!isTransformed) { |
| return node; |
| } |
| |
| final newName = '${target.name.text}#$methodPostfix'; |
| final Procedure newTarget; |
| final parent = target.parent; |
| final members = switch (parent) { |
| Library _ => parent.members, |
| Class _ => parent.members, |
| _ => throw UnimplementedError('Unexpected parent: ${parent}'), |
| }; |
| |
| final existingNewTarget = members |
| .whereType<Procedure>() |
| .where((element) => element.name.text == newName) |
| .firstOrNull; |
| if (existingNewTarget != null) { |
| newTarget = existingNewTarget; |
| } else { |
| final cloner = CloneProcedureWithoutBody(); |
| newTarget = cloner.cloneProcedure(target, null); |
| newTarget.name = Name(newName); |
| newTarget.function.positionalParameters = newParameters; |
| setParents(newParameters, newTarget.function); |
| switch (parent) { |
| case Library _: |
| parent.addProcedure(newTarget); |
| case Class _: |
| parent.addProcedure(newTarget); |
| } |
| } |
| |
| return StaticInvocation( |
| newTarget, |
| Arguments(newArguments), |
| ); |
| } |
| |
| /// Converts a single parameter with argument for [_replaceNativeCall]. |
| ( |
| /// '' for non-Pointer. |
| /// 'P' for Pointer. |
| /// 'T' for TypedData. |
| /// 'C' for _Compound (TypedData/Pointer and offset in bytes). |
| /// 'E' for errors. |
| String methodPostFix, |
| DartType parameterType, |
| Expression argument, |
| ) _replaceNativeCallParameterAndArgument( |
| VariableDeclaration parameter, |
| DartType parameterType, |
| Expression argument, |
| int fileOffset, |
| ) { |
| if (parameterType is! InterfaceType || |
| parameterType.classNode != pointerClass) { |
| // Parameter is non-pointer. Keep unchanged. |
| return ('', parameterType, argument); |
| } |
| |
| if (argument is! StaticInvocation || |
| !addressOfMethods.contains(argument.target)) { |
| // The argument has type Pointer, but it's not produced by any of the |
| // `.address` getters. |
| // Argument must be a Pointer object. Keep unchanged. |
| return ('P', parameterType, argument); |
| } |
| |
| if (addressOfMethodsTypedData.contains(argument.target)) { |
| final subExpression = argument.arguments.positional.single; |
| // Argument is `typedData.address`. |
| final typedDataType = InterfaceType( |
| typedDataClass, |
| Nullability.nonNullable, |
| const <DartType>[], |
| ); |
| return ('T', typedDataType, subExpression); |
| } |
| |
| final subExpression = argument.arguments.positional.single; |
| |
| if (addressOfMethodsCompound.contains(argument.target)) { |
| // Argument is `structOrUnionOrArray.address`. |
| return ('C', compoundType, subExpression); |
| } |
| |
| assert(addressOfMethodsPrimitive.contains(argument.target)); |
| // Argument is an `expr.address` where `expr` is typed `bool`, `int`, or |
| // `double`. Analyze `expr` further. |
| switch (subExpression) { |
| case InstanceGet _: |
| // Look for `structOrUnion.member.address`. |
| final interfaceTarget = subExpression.interfaceTarget; |
| final enclosingClass = interfaceTarget.enclosingClass!; |
| final targetSuperClass = enclosingClass.superclass; |
| if (targetSuperClass == unionClass) { |
| // `expr` is a union member access. |
| // Union members have no additional offset. Pass in unchanged. |
| return ('C', compoundType, subExpression.receiver); |
| } |
| if (targetSuperClass == structClass) { |
| final getterName = interfaceTarget.name.text; |
| final offsetOfName = '$getterName#offsetOf'; |
| final offsetGetter = enclosingClass.procedures |
| .firstWhere((e) => e.name.text == offsetOfName); |
| // `expr` is a struct member access. Struct members have an offset. |
| // Pass in a newly constructed `_Compound`, with adjusted offset. |
| return ( |
| 'C', |
| compoundType, |
| _generateCompoundOffsetBy( |
| subExpression.receiver, |
| StaticGet(offsetGetter), |
| fileOffset, |
| variableName: "${parameter.name}#value", |
| ), |
| ); |
| } |
| // Error, unrecognized getter. |
| |
| case StaticInvocation _: |
| // Look for `array[index].address`. |
| // Extensions have already been desugared, so no enclosing extension. |
| final target = subExpression.target; |
| if (!target.isExtensionMember) break; |
| final positionalParameters = target.function.positionalParameters; |
| if (positionalParameters.length != 2) break; |
| final firstParamType = positionalParameters.first.type; |
| if (firstParamType is! InterfaceType) break; |
| if (firstParamType.classNode != arrayClass) break; |
| // Extensions have already been desugared, so original name is lost. |
| if (!target.name.text.endsWith('|[]')) break; |
| final DartType arrayElementType; |
| if (subExpression.arguments.types.isNotEmpty) { |
| // AbiSpecificInteger. |
| arrayElementType = subExpression.arguments.types.single; |
| } else { |
| arrayElementType = firstParamType.typeArguments.single; |
| } |
| final arrayElementSize = |
| inlineSizeOf(arrayElementType as InterfaceType)!; |
| // Array element. Pass in a newly constructed `_Compound`, with |
| // adjusted offset. |
| return ( |
| 'C', |
| compoundType, |
| _generateCompoundOffsetBy( |
| subExpression.arguments.positional[0], |
| multiply( |
| arrayElementSize, |
| subExpression.arguments.positional[1], // index. |
| ), |
| fileOffset, |
| variableName: "${parameter.name}#value", |
| ), |
| ); |
| |
| case InstanceInvocation _: |
| // Look for `typedData[index].address` |
| final receiverType = |
| staticTypeContext!.getExpressionType(subExpression.receiver); |
| final implementsTypedData = TypeEnvironment(coreTypes, hierarchy) |
| .isSubtypeOf( |
| receiverType, |
| InterfaceType(typedDataClass, Nullability.nonNullable), |
| SubtypeCheckMode.withNullabilities); |
| if (!implementsTypedData) break; |
| if (receiverType is! InterfaceType) break; |
| final classNode = receiverType.classNode; |
| final elementSizeInBytes = _typedDataElementSizeInBytes(classNode); |
| if (elementSizeInBytes == null) break; |
| |
| // Typed Data element off. Pass in new _Compound with extra |
| // offset. |
| return ( |
| 'C', |
| compoundType, |
| ConstructorInvocation( |
| compoundFromTypedDataBase, |
| Arguments([ |
| subExpression.receiver, |
| multiply( |
| ConstantExpression(IntConstant(elementSizeInBytes)), |
| subExpression.arguments.positional.first, // index. |
| ), |
| ]), |
| ), |
| ); |
| default: |
| } |
| |
| diagnosticReporter.report( |
| messageFfiAddressReceiver, |
| argument.fileOffset, |
| 1, |
| argument.location?.file, |
| ); |
| // Pass nullptr to prevent cascading error messages. |
| return ( |
| 'E', // Error. |
| pointerVoidType, |
| StaticInvocation( |
| fromAddressInternal, |
| Arguments( |
| <Expression>[ConstantExpression(IntConstant(0))], |
| types: <DartType>[voidType], |
| ), |
| ), |
| ); |
| } |
| |
| int? _typedDataElementSizeInBytes(Class classNode) { |
| final name = classNode.name; |
| if (name.contains('8')) { |
| return 1; |
| } else if (name.contains('16')) { |
| return 2; |
| } else if (name.contains('32')) { |
| return 4; |
| } else if (name.contains('64')) { |
| return 8; |
| } |
| return null; |
| } |
| |
| /// Returns: |
| /// |
| /// ``` |
| /// _Compound._fromTypedDataBase( |
| /// compound._typedDataBase, |
| /// compound._offsetInBytes + offsetInBytes, |
| /// ) |
| /// ``` |
| Expression _generateCompoundOffsetBy( |
| Expression compound, |
| Expression offsetInBytes, |
| int fileOffset, { |
| String variableName = "#compoundOffset", |
| }) { |
| final compoundType = InterfaceType( |
| compoundClass, |
| Nullability.nonNullable, |
| const <DartType>[], |
| ); |
| |
| final valueVar = VariableDeclaration( |
| variableName, |
| initializer: compound, |
| type: compoundType, |
| isSynthesized: true, |
| )..fileOffset = fileOffset; |
| final newArgument = BlockExpression( |
| Block([ |
| valueVar, |
| ]), |
| ConstructorInvocation( |
| compoundFromTypedDataBase, |
| Arguments([ |
| getCompoundTypedDataBaseField( |
| VariableGet(valueVar), |
| fileOffset, |
| ), |
| add( |
| getCompoundOffsetInBytesField( |
| VariableGet(valueVar), |
| fileOffset, |
| ), |
| offsetInBytes, |
| ), |
| ]), |
| ), |
| ); |
| return newArgument; |
| } |
| } |
| |
| extension<T extends Object> on List<T> { |
| /// Order-preserved distinct elements. |
| List<T> distinct() { |
| final seen = <T>{}; |
| return where((element) => seen.add(element)).toList(); |
| } |
| } |
