blob: 1551f46258fcfba4523c1af883f607e30fb0138d [file] [log] [blame]
// 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.
// This file contains logic which is shared between the ffi_definition and
// ffi_use_site transformers.
library vm.transformations.ffi;
import 'package:kernel/ast.dart' hide MapEntry;
import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
import 'package:kernel/core_types.dart';
import 'package:kernel/library_index.dart' show LibraryIndex;
import 'package:kernel/reference_from_index.dart';
import 'package:kernel/target/targets.dart' show DiagnosticReporter;
import 'package:kernel/type_environment.dart'
show TypeEnvironment, SubtypeCheckMode;
/// Represents the (instantiated) ffi.NativeType.
enum NativeType {
kNativeType,
kNativeInteger,
kNativeDouble,
kPointer,
kNativeFunction,
kInt8,
kInt16,
kInt32,
kInt64,
kUint8,
kUint16,
kUint32,
kUnit64,
kIntptr,
kFloat,
kDouble,
kVoid,
kOpaque,
kStruct,
kHandle,
}
const NativeType kNativeTypeIntStart = NativeType.kInt8;
const NativeType kNativeTypeIntEnd = NativeType.kIntptr;
/// The [NativeType] class names, indexed by [NativeType].
const List<String> nativeTypeClassNames = [
'NativeType',
'_NativeInteger',
'_NativeDouble',
'Pointer',
'NativeFunction',
'Int8',
'Int16',
'Int32',
'Int64',
'Uint8',
'Uint16',
'Uint32',
'Uint64',
'IntPtr',
'Float',
'Double',
'Void',
'Opaque',
'Struct',
'Handle'
];
const int UNKNOWN = 0;
const int WORD_SIZE = -1;
/// The [NativeType] sizes in bytes, indexed by [NativeType].
const List<int> nativeTypeSizes = [
UNKNOWN, // NativeType
UNKNOWN, // NativeInteger
UNKNOWN, // NativeDouble
WORD_SIZE, // Pointer
UNKNOWN, // NativeFunction
1, // Int8
2, // Int16
4, // Int32
8, // Int64
1, // Uint8
2, // Uint16
4, // Uint32
8, // Uint64
WORD_SIZE, // IntPtr
4, // Float
8, // Double
UNKNOWN, // Void
UNKNOWN, // Opaque
UNKNOWN, // Struct
WORD_SIZE, // Handle
];
/// The struct layout in various ABIs.
///
/// ABIs differ per architectures and with different compilers.
/// We pick the default struct layout based on the architecture and OS.
///
/// Compilers _can_ deviate from the default layout, but this prevents
/// executables from making system calls. So this seems rather uncommon.
///
/// In the future, we might support custom struct layouts. For more info see
/// https://github.com/dart-lang/sdk/issues/35768.
enum Abi {
/// Layout in all 64bit ABIs (x64 and arm64).
wordSize64,
/// Layout in System V ABI for x386 (ia32 on Linux) and in iOS Arm 32 bit.
wordSize32Align32,
/// Layout in both the Arm 32 bit ABI and the Windows ia32 ABI.
wordSize32Align64,
}
/// WORD_SIZE in bytes.
const wordSize = <Abi, int>{
Abi.wordSize64: 8,
Abi.wordSize32Align32: 4,
Abi.wordSize32Align64: 4,
};
/// Elements that are not aligned to their size.
///
/// Has an entry for all Abis. Empty entries document that every native
/// type is aligned to it's own size in this ABI.
///
/// See runtime/vm/ffi/abi.cc for asserts in the VM that verify these
/// alignments.
///
/// TODO(37470): Add uncommon primitive data types when we want to support them.
const nonSizeAlignment = <Abi, Map<NativeType, int>>{
Abi.wordSize64: {},
// x86 System V ABI:
// > uint64_t | size 8 | alignment 4
// > double | size 8 | alignment 4
// https://github.com/hjl-tools/x86-psABI/wiki/intel386-psABI-1.1.pdf page 8.
//
// iOS 32 bit alignment:
// https://developer.apple.com/documentation/uikit/app_and_environment/updating_your_app_from_32-bit_to_64-bit_architecture/updating_data_structures
Abi.wordSize32Align32: {
NativeType.kDouble: 4,
NativeType.kInt64: 4,
NativeType.kUnit64: 4
},
// The default for MSVC x86:
// > The alignment-requirement for all data except structures, unions, and
// > arrays is either the size of the object or the current packing size
// > (specified with either /Zp or the pack pragma, whichever is less).
// https://docs.microsoft.com/en-us/cpp/c-language/padding-and-alignment-of-structure-members?view=vs-2019
//
// GCC _can_ compile on Linux to this alignment with -malign-double, but does
// not do so by default:
// > Warning: if you use the -malign-double switch, structures containing the
// > above types are aligned differently than the published application
// > binary interface specifications for the x86-32 and are not binary
// > compatible with structures in code compiled without that switch.
// https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html
//
// Arm always requires 8 byte alignment for 8 byte values:
// http://infocenter.arm.com/help/topic/com.arm.doc.ihi0042d/IHI0042D_aapcs.pdf 4.1 Fundamental Data Types
Abi.wordSize32Align64: {},
};
/// Load, store, and elementAt are rewired to their static type for these types.
const List<NativeType> optimizedTypes = [
NativeType.kInt8,
NativeType.kInt16,
NativeType.kInt32,
NativeType.kInt64,
NativeType.kUint8,
NativeType.kUint16,
NativeType.kUint32,
NativeType.kUnit64,
NativeType.kIntptr,
NativeType.kFloat,
NativeType.kDouble,
NativeType.kPointer,
];
const List<NativeType> unalignedLoadsStores = [
NativeType.kFloat,
NativeType.kDouble,
];
/// [FfiTransformer] contains logic which is shared between
/// _FfiUseSiteTransformer and _FfiDefinitionTransformer.
class FfiTransformer extends Transformer {
final TypeEnvironment env;
final CoreTypes coreTypes;
final LibraryIndex index;
final ClassHierarchy hierarchy;
final DiagnosticReporter diagnosticReporter;
final ReferenceFromIndex referenceFromIndex;
final Class objectClass;
final Class intClass;
final Class doubleClass;
final Class listClass;
final Class typeClass;
final Procedure unsafeCastMethod;
final Class typedDataClass;
final Procedure typedDataBufferGetter;
final Procedure typedDataOffsetInBytesGetter;
final Procedure byteBufferAsUint8List;
final Class pragmaClass;
final Field pragmaName;
final Field pragmaOptions;
final Procedure listElementAt;
final Procedure numAddition;
final Procedure numMultiplication;
final Library ffiLibrary;
final Class allocatorClass;
final Class nativeFunctionClass;
final Class opaqueClass;
final Class arrayClass;
final Class arraySizeClass;
final Field arraySizeDimension1Field;
final Field arraySizeDimension2Field;
final Field arraySizeDimension3Field;
final Field arraySizeDimension4Field;
final Field arraySizeDimension5Field;
final Field arraySizeDimensionsField;
final Class pointerClass;
final Class structClass;
final Class ffiStructLayoutClass;
final Field ffiStructLayoutTypesField;
final Field ffiStructLayoutPackingField;
final Class ffiInlineArrayClass;
final Field ffiInlineArrayElementTypeField;
final Field ffiInlineArrayLengthField;
final Class packedClass;
final Field packedMemberAlignmentField;
final Procedure allocateMethod;
final Procedure allocatorAllocateMethod;
final Procedure castMethod;
final Procedure offsetByMethod;
final Procedure elementAtMethod;
final Procedure addressGetter;
final Procedure structPointerRef;
final Procedure structPointerElemAt;
final Procedure structArrayElemAt;
final Procedure arrayArrayElemAt;
final Procedure arrayArrayAssignAt;
final Procedure asFunctionMethod;
final Procedure asFunctionInternal;
final Procedure sizeOfMethod;
final Procedure lookupFunctionMethod;
final Procedure fromFunctionMethod;
final Field addressOfField;
final Field arrayTypedDataBaseField;
final Field arraySizeField;
final Field arrayNestedDimensionsField;
final Procedure arrayCheckIndex;
final Field arrayNestedDimensionsFlattened;
final Field arrayNestedDimensionsFirst;
final Field arrayNestedDimensionsRest;
final Constructor structFromPointer;
final Constructor arrayConstructor;
final Procedure fromAddressInternal;
final Procedure libraryLookupMethod;
final Procedure abiMethod;
final Procedure pointerFromFunctionProcedure;
final Procedure nativeCallbackFunctionProcedure;
final Map<NativeType, Procedure> loadMethods;
final Map<NativeType, Procedure> loadUnalignedMethods;
final Map<NativeType, Procedure> storeMethods;
final Map<NativeType, Procedure> storeUnalignedMethods;
final Map<NativeType, Procedure> elementAtMethods;
final Procedure memCopy;
final Procedure allocationTearoff;
final Procedure asFunctionTearoff;
final Procedure lookupFunctionTearoff;
/// Classes corresponding to [NativeType], indexed by [NativeType].
final List<Class> nativeTypesClasses;
Library currentLibrary;
IndexedLibrary currentLibraryIndex;
FfiTransformer(this.index, this.coreTypes, this.hierarchy,
this.diagnosticReporter, this.referenceFromIndex)
: env = new TypeEnvironment(coreTypes, hierarchy),
objectClass = coreTypes.objectClass,
intClass = coreTypes.intClass,
doubleClass = coreTypes.doubleClass,
listClass = coreTypes.listClass,
typeClass = coreTypes.typeClass,
unsafeCastMethod =
index.getTopLevelMember('dart:_internal', 'unsafeCast'),
typedDataClass = index.getClass('dart:typed_data', 'TypedData'),
typedDataBufferGetter =
index.getMember('dart:typed_data', 'TypedData', 'get:buffer'),
typedDataOffsetInBytesGetter = index.getMember(
'dart:typed_data', 'TypedData', 'get:offsetInBytes'),
byteBufferAsUint8List =
index.getMember('dart:typed_data', 'ByteBuffer', 'asUint8List'),
pragmaClass = coreTypes.pragmaClass,
pragmaName = coreTypes.pragmaName,
pragmaOptions = coreTypes.pragmaOptions,
listElementAt = coreTypes.index.getMember('dart:core', 'List', '[]'),
numAddition = coreTypes.index.getMember('dart:core', 'num', '+'),
numMultiplication = coreTypes.index.getMember('dart:core', 'num', '*'),
ffiLibrary = index.getLibrary('dart:ffi'),
allocatorClass = index.getClass('dart:ffi', 'Allocator'),
nativeFunctionClass = index.getClass('dart:ffi', 'NativeFunction'),
opaqueClass = index.getClass('dart:ffi', 'Opaque'),
arrayClass = index.getClass('dart:ffi', 'Array'),
arraySizeClass = index.getClass('dart:ffi', '_ArraySize'),
arraySizeDimension1Field =
index.getMember('dart:ffi', '_ArraySize', 'dimension1'),
arraySizeDimension2Field =
index.getMember('dart:ffi', '_ArraySize', 'dimension2'),
arraySizeDimension3Field =
index.getMember('dart:ffi', '_ArraySize', 'dimension3'),
arraySizeDimension4Field =
index.getMember('dart:ffi', '_ArraySize', 'dimension4'),
arraySizeDimension5Field =
index.getMember('dart:ffi', '_ArraySize', 'dimension5'),
arraySizeDimensionsField =
index.getMember('dart:ffi', '_ArraySize', 'dimensions'),
pointerClass = index.getClass('dart:ffi', 'Pointer'),
structClass = index.getClass('dart:ffi', 'Struct'),
ffiStructLayoutClass = index.getClass('dart:ffi', '_FfiStructLayout'),
ffiStructLayoutTypesField =
index.getMember('dart:ffi', '_FfiStructLayout', 'fieldTypes'),
ffiStructLayoutPackingField =
index.getMember('dart:ffi', '_FfiStructLayout', 'packing'),
ffiInlineArrayClass = index.getClass('dart:ffi', '_FfiInlineArray'),
ffiInlineArrayElementTypeField =
index.getMember('dart:ffi', '_FfiInlineArray', 'elementType'),
ffiInlineArrayLengthField =
index.getMember('dart:ffi', '_FfiInlineArray', 'length'),
packedClass = index.getClass('dart:ffi', 'Packed'),
packedMemberAlignmentField =
index.getMember('dart:ffi', 'Packed', 'memberAlignment'),
allocateMethod = index.getMember('dart:ffi', 'AllocatorAlloc', 'call'),
allocatorAllocateMethod =
index.getMember('dart:ffi', 'Allocator', 'allocate'),
castMethod = index.getMember('dart:ffi', 'Pointer', 'cast'),
offsetByMethod = index.getMember('dart:ffi', 'Pointer', '_offsetBy'),
elementAtMethod = index.getMember('dart:ffi', 'Pointer', 'elementAt'),
addressGetter = index.getMember('dart:ffi', 'Pointer', 'get:address'),
addressOfField = index.getMember('dart:ffi', 'Struct', '_addressOf'),
arrayTypedDataBaseField =
index.getMember('dart:ffi', 'Array', '_typedDataBase'),
arraySizeField = index.getMember('dart:ffi', 'Array', '_size'),
arrayNestedDimensionsField =
index.getMember('dart:ffi', 'Array', '_nestedDimensions'),
arrayCheckIndex = index.getMember('dart:ffi', 'Array', '_checkIndex'),
arrayNestedDimensionsFlattened =
index.getMember('dart:ffi', 'Array', '_nestedDimensionsFlattened'),
arrayNestedDimensionsFirst =
index.getMember('dart:ffi', 'Array', '_nestedDimensionsFirst'),
arrayNestedDimensionsRest =
index.getMember('dart:ffi', 'Array', '_nestedDimensionsRest'),
structFromPointer =
index.getMember('dart:ffi', 'Struct', '_fromPointer'),
arrayConstructor = index.getMember('dart:ffi', 'Array', '_'),
fromAddressInternal =
index.getTopLevelMember('dart:ffi', '_fromAddress'),
structPointerRef =
index.getMember('dart:ffi', 'StructPointer', 'get:ref'),
structPointerElemAt =
index.getMember('dart:ffi', 'StructPointer', '[]'),
structArrayElemAt = index.getMember('dart:ffi', 'StructArray', '[]'),
arrayArrayElemAt = index.getMember('dart:ffi', 'ArrayArray', '[]'),
arrayArrayAssignAt = index.getMember('dart:ffi', 'ArrayArray', '[]='),
asFunctionMethod =
index.getMember('dart:ffi', 'NativeFunctionPointer', 'asFunction'),
asFunctionInternal =
index.getTopLevelMember('dart:ffi', '_asFunctionInternal'),
sizeOfMethod = index.getTopLevelMember('dart:ffi', 'sizeOf'),
lookupFunctionMethod = index.getMember(
'dart:ffi', 'DynamicLibraryExtension', 'lookupFunction'),
fromFunctionMethod =
index.getMember('dart:ffi', 'Pointer', 'fromFunction'),
libraryLookupMethod =
index.getMember('dart:ffi', 'DynamicLibrary', 'lookup'),
abiMethod = index.getTopLevelMember('dart:ffi', '_abi'),
pointerFromFunctionProcedure =
index.getTopLevelMember('dart:ffi', '_pointerFromFunction'),
nativeCallbackFunctionProcedure =
index.getTopLevelMember('dart:ffi', '_nativeCallbackFunction'),
nativeTypesClasses = nativeTypeClassNames
.map((name) => index.getClass('dart:ffi', name))
.toList(),
loadMethods = Map.fromIterable(optimizedTypes, value: (t) {
final name = nativeTypeClassNames[t.index];
return index.getTopLevelMember('dart:ffi', "_load$name");
}),
loadUnalignedMethods =
Map.fromIterable(unalignedLoadsStores, value: (t) {
final name = nativeTypeClassNames[t.index];
return index.getTopLevelMember('dart:ffi', "_load${name}Unaligned");
}),
storeMethods = Map.fromIterable(optimizedTypes, value: (t) {
final name = nativeTypeClassNames[t.index];
return index.getTopLevelMember('dart:ffi', "_store$name");
}),
storeUnalignedMethods =
Map.fromIterable(unalignedLoadsStores, value: (t) {
final name = nativeTypeClassNames[t.index];
return index.getTopLevelMember('dart:ffi', "_store${name}Unaligned");
}),
elementAtMethods = Map.fromIterable(optimizedTypes, value: (t) {
final name = nativeTypeClassNames[t.index];
return index.getTopLevelMember('dart:ffi', "_elementAt$name");
}),
memCopy = index.getTopLevelMember('dart:ffi', '_memCopy'),
allocationTearoff = index.getMember(
'dart:ffi', 'AllocatorAlloc', LibraryIndex.tearoffPrefix + 'call'),
asFunctionTearoff = index.getMember('dart:ffi', 'NativeFunctionPointer',
LibraryIndex.tearoffPrefix + 'asFunction'),
lookupFunctionTearoff = index.getMember(
'dart:ffi',
'DynamicLibraryExtension',
LibraryIndex.tearoffPrefix + 'lookupFunction');
@override
TreeNode visitLibrary(Library node) {
assert(currentLibrary == null);
currentLibrary = node;
currentLibraryIndex = referenceFromIndex?.lookupLibrary(node);
final result = super.visitLibrary(node);
currentLibrary = null;
return result;
}
/// Computes the Dart type corresponding to a ffi.[NativeType], returns null
/// if it is not a valid NativeType.
///
/// [Int8] -> [int]
/// [Int16] -> [int]
/// [Int32] -> [int]
/// [Int64] -> [int]
/// [Uint8] -> [int]
/// [Uint16] -> [int]
/// [Uint32] -> [int]
/// [Uint64] -> [int]
/// [IntPtr] -> [int]
/// [Double] -> [double]
/// [Float] -> [double]
/// [Void] -> [void]
/// [Pointer]<T> -> [Pointer]<T>
/// T extends [Pointer] -> T
/// [Handle] -> [Object]
/// [NativeFunction]<T1 Function(T2, T3) -> S1 Function(S2, S3)
/// where DartRepresentationOf(Tn) -> Sn
DartType convertNativeTypeToDartType(DartType nativeType,
{bool allowStructs = false,
bool allowStructItself = false,
bool allowHandle = false,
bool allowInlineArray = false}) {
if (nativeType is! InterfaceType) {
return null;
}
final InterfaceType native = nativeType;
final Class nativeClass = native.classNode;
final NativeType nativeType_ = getType(nativeClass);
if (nativeClass == arrayClass) {
if (!allowInlineArray) {
return null;
}
return nativeType;
}
if (hierarchy.isSubclassOf(nativeClass, structClass)) {
if (structClass == nativeClass) {
return allowStructItself ? nativeType : null;
}
return allowStructs ? nativeType : null;
}
if (nativeType_ == null) {
return null;
}
if (nativeType_ == NativeType.kPointer) {
return nativeType;
}
if (kNativeTypeIntStart.index <= nativeType_.index &&
nativeType_.index <= kNativeTypeIntEnd.index) {
return InterfaceType(intClass, Nullability.legacy);
}
if (nativeType_ == NativeType.kFloat || nativeType_ == NativeType.kDouble) {
return InterfaceType(doubleClass, Nullability.legacy);
}
if (nativeType_ == NativeType.kVoid) {
return VoidType();
}
if (nativeType_ == NativeType.kHandle && allowHandle) {
return InterfaceType(objectClass, Nullability.legacy);
}
if (nativeType_ != NativeType.kNativeFunction ||
native.typeArguments[0] is! FunctionType) {
return null;
}
final FunctionType fun = native.typeArguments[0];
if (fun.namedParameters.isNotEmpty) return null;
if (fun.positionalParameters.length != fun.requiredParameterCount) {
return null;
}
if (fun.typeParameters.length != 0) return null;
final DartType returnType = convertNativeTypeToDartType(fun.returnType,
allowStructs: allowStructs, allowHandle: true);
if (returnType == null) return null;
final List<DartType> argumentTypes = fun.positionalParameters
.map((t) => convertNativeTypeToDartType(t,
allowStructs: allowStructs, allowHandle: true))
.toList();
if (argumentTypes.contains(null)) return null;
return FunctionType(argumentTypes, returnType, Nullability.legacy);
}
/// The [NativeType] corresponding to [c]. Returns `null` for user-defined
/// structs.
NativeType getType(Class c) {
final int index = nativeTypesClasses.indexOf(c);
if (index == -1) {
return null;
}
return NativeType.values[index];
}
ConstantExpression intListConstantExpression(List<int> values) =>
ConstantExpression(
ListConstant(InterfaceType(intClass, Nullability.legacy),
[for (var v in values) IntConstant(v)]),
InterfaceType(listClass, Nullability.legacy,
[InterfaceType(intClass, Nullability.legacy)]));
/// Expression that queries VM internals at runtime to figure out on which ABI
/// we are.
Expression runtimeBranchOnLayout(Map<Abi, int> values) {
return MethodInvocation(
intListConstantExpression([
values[Abi.wordSize64],
values[Abi.wordSize32Align32],
values[Abi.wordSize32Align64]
]),
Name("[]"),
Arguments([StaticInvocation(abiMethod, Arguments([]))]),
listElementAt);
}
/// Generates an expression that returns a new `Pointer<dartType>` offset
/// by [offset] from [pointer].
///
/// Sample output:
///
/// ```
/// _fromAddress<dartType>(pointer.address + #offset)
/// ```
Expression _pointerOffset(Expression pointer, Expression offset,
DartType dartType, int fileOffset) =>
StaticInvocation(
fromAddressInternal,
Arguments([
MethodInvocation(
PropertyGet(pointer, addressGetter.name, addressGetter)
..fileOffset = fileOffset,
numAddition.name,
Arguments([offset]),
numAddition)
], types: [
dartType
]))
..fileOffset = fileOffset;
/// Generates an expression that returns a new `TypedData` offset
/// by [offset] from [typedData].
///
/// Sample output:
///
/// ```
/// TypedData #typedData = typedData;
/// #typedData.buffer.asInt8List(#typedData.offsetInBytes + offset, length)
/// ```
Expression _typedDataOffset(Expression typedData, Expression offset,
Expression length, int fileOffset) {
final typedDataVar = VariableDeclaration("#typedData",
initializer: typedData,
type: InterfaceType(typedDataClass, Nullability.nonNullable))
..fileOffset = fileOffset;
return Let(
typedDataVar,
MethodInvocation(
PropertyGet(VariableGet(typedDataVar), typedDataBufferGetter.name,
typedDataBufferGetter)
..fileOffset = fileOffset,
byteBufferAsUint8List.name,
Arguments([
MethodInvocation(
PropertyGet(
VariableGet(typedDataVar),
typedDataOffsetInBytesGetter.name,
typedDataOffsetInBytesGetter)
..fileOffset = fileOffset,
numAddition.name,
Arguments([offset]),
numAddition),
length
]),
byteBufferAsUint8List));
}
/// Generates an expression that returns a new `TypedDataBase` offset
/// by [offset] from [typedDataBase].
///
/// If [typedDataBase] is a `Pointer`, returns a `Pointer<dartType>`.
/// If [typedDataBase] is a `TypedData` returns a `TypedData`.
///
/// Sample output:
///
/// ```
/// Object #typedDataBase = typedDataBase;
/// int #offset = offset;
/// #typedDataBase is Pointer ?
/// _pointerOffset<dartType>(#typedDataBase, #offset) :
/// _typedDataOffset((#typedDataBase as TypedData), #offset, length)
/// ```
Expression typedDataBaseOffset(Expression typedDataBase, Expression offset,
Expression length, DartType dartType, int fileOffset) {
final typedDataBaseVar = VariableDeclaration("#typedDataBase",
initializer: typedDataBase, type: coreTypes.objectNonNullableRawType)
..fileOffset = fileOffset;
final offsetVar = VariableDeclaration("#offset",
initializer: offset, type: coreTypes.intNonNullableRawType)
..fileOffset = fileOffset;
return BlockExpression(
Block([typedDataBaseVar, offsetVar]),
ConditionalExpression(
IsExpression(VariableGet(typedDataBaseVar),
InterfaceType(pointerClass, Nullability.nonNullable)),
_pointerOffset(VariableGet(typedDataBaseVar),
VariableGet(offsetVar), dartType, fileOffset),
_typedDataOffset(
StaticInvocation(
unsafeCastMethod,
Arguments([
VariableGet(typedDataBaseVar)
], types: [
InterfaceType(typedDataClass, Nullability.nonNullable)
])),
VariableGet(offsetVar),
length,
fileOffset),
coreTypes.objectNonNullableRawType));
}
bool isPrimitiveType(DartType type) {
if (type is InvalidType) {
return false;
}
if (type is NullType) {
return false;
}
if (!env.isSubtypeOf(
type,
InterfaceType(nativeTypesClasses[NativeType.kNativeType.index],
Nullability.legacy),
SubtypeCheckMode.ignoringNullabilities)) {
return false;
}
if (isPointerType(type)) {
return false;
}
if (type is InterfaceType) {
final nativeType = getType(type.classNode);
return nativeType != null;
}
return false;
}
bool isPointerType(DartType type) {
if (type is InvalidType) {
return false;
}
if (type is NullType) {
return false;
}
return env.isSubtypeOf(
type,
InterfaceType(pointerClass, Nullability.legacy, [
InterfaceType(nativeTypesClasses[NativeType.kNativeType.index],
Nullability.legacy)
]),
SubtypeCheckMode.ignoringNullabilities);
}
bool isArrayType(DartType type) {
if (type is InvalidType) {
return false;
}
if (type is NullType) {
return false;
}
return env.isSubtypeOf(
type,
InterfaceType(arrayClass, Nullability.legacy, [
InterfaceType(nativeTypesClasses[NativeType.kNativeType.index],
Nullability.legacy)
]),
SubtypeCheckMode.ignoringNullabilities);
}
/// Returns the single element type nested type argument of `Array`.
///
/// `Array<Array<Array<Int8>>>` -> `Int8`.
DartType arraySingleElementType(DartType dartType) {
InterfaceType elementType = dartType as InterfaceType;
while (elementType.classNode == arrayClass) {
elementType = elementType.typeArguments[0] as InterfaceType;
}
return elementType;
}
/// Returns the number of dimensions of `Array`.
///
/// `Array<Array<Array<Int8>>>` -> 3.
int arrayDimensions(DartType dartType) {
InterfaceType elementType = dartType as InterfaceType;
int dimensions = 0;
while (elementType.classNode == arrayClass) {
elementType = elementType.typeArguments[0] as InterfaceType;
dimensions++;
}
return dimensions;
}
bool isStructSubtype(DartType type) {
if (type is InvalidType) {
return false;
}
if (type is NullType) {
return false;
}
if (type is InterfaceType) {
if (type.classNode == structClass) {
return false;
}
}
return env.isSubtypeOf(type, InterfaceType(structClass, Nullability.legacy),
SubtypeCheckMode.ignoringNullabilities);
}
}
/// Contains all information collected by _FfiDefinitionTransformer that is
/// needed in _FfiUseSiteTransformer.
class FfiTransformerData {
final Map<Field, Procedure> replacedGetters;
final Map<Field, Procedure> replacedSetters;
final Set<Class> emptyStructs;
FfiTransformerData(
this.replacedGetters, this.replacedSetters, this.emptyStructs);
}
/// Checks if any library depends on dart:ffi.
bool importsFfi(Component component, List<Library> libraries) {
Set<Library> allLibs = {...component.libraries, ...libraries};
final Uri dartFfiUri = Uri.parse("dart:ffi");
for (Library lib in allLibs) {
for (LibraryDependency dependency in lib.dependencies) {
if (dependency.targetLibrary.importUri == dartFfiUri) {
return true;
}
}
}
return false;
}