diff --git a/pkg/analyzer/lib/error/error.dart b/pkg/analyzer/lib/error/error.dart
index cc621a7..b4924ce 100644
--- a/pkg/analyzer/lib/error/error.dart
+++ b/pkg/analyzer/lib/error/error.dart
@@ -477,6 +477,9 @@
   CompileTimeErrorCode.YIELD_IN_NON_GENERATOR,
   CompileTimeErrorCode.YIELD_EACH_OF_INVALID_TYPE,
   CompileTimeErrorCode.YIELD_OF_INVALID_TYPE,
+  FfiCode.ABI_SPECIFIC_INTEGER_MAPPING_EXTRA,
+  FfiCode.ABI_SPECIFIC_INTEGER_MAPPING_MISSING,
+  FfiCode.ABI_SPECIFIC_INTEGER_MAPPING_UNSUPPORTED,
   FfiCode.ANNOTATION_ON_POINTER_FIELD,
   FfiCode.ARGUMENT_MUST_BE_A_CONSTANT,
   FfiCode.CREATION_OF_STRUCT_OR_UNION,
diff --git a/pkg/analyzer/lib/src/dart/error/ffi_code.g.dart b/pkg/analyzer/lib/src/dart/error/ffi_code.g.dart
index 4264f45..e794a9b 100644
--- a/pkg/analyzer/lib/src/dart/error/ffi_code.g.dart
+++ b/pkg/analyzer/lib/src/dart/error/ffi_code.g.dart
@@ -18,6 +18,34 @@
   /**
    * No parameters.
    */
+  static const FfiCode ABI_SPECIFIC_INTEGER_MAPPING_EXTRA = FfiCode(
+    'ABI_SPECIFIC_INTEGER_MAPPING_EXTRA',
+    "Classes extending 'AbiSpecificInteger' must have exactly one 'AbiSpecificIntegerMapping' annotation specifying the mapping from ABI to a 'NativeType' integer with a fixed size.",
+    correctionMessage: "Try removing the extra annotation.",
+  );
+
+  /**
+   * No parameters.
+   */
+  static const FfiCode ABI_SPECIFIC_INTEGER_MAPPING_MISSING = FfiCode(
+    'ABI_SPECIFIC_INTEGER_MAPPING_MISSING',
+    "Classes extending 'AbiSpecificInteger' must have exactly one 'AbiSpecificIntegerMapping' annotation specifying the mapping from ABI to a 'NativeType' integer with a fixed size.",
+    correctionMessage: "Try adding an annotation.",
+  );
+
+  /**
+   * No parameters.
+   */
+  static const FfiCode ABI_SPECIFIC_INTEGER_MAPPING_UNSUPPORTED = FfiCode(
+    'ABI_SPECIFIC_INTEGER_MAPPING_UNSUPPORTED',
+    "Only mappings to 'Int8', 'Int16', 'Int32', 'Int64', 'Uint8', 'Uint16', 'UInt32', and 'Uint64' are supported.",
+    correctionMessage:
+        "Try changing the value to 'Int8', 'Int16', 'Int32', 'Int64', 'Uint8', 'Uint16', 'UInt32', or 'Uint64'.",
+  );
+
+  /**
+   * No parameters.
+   */
   static const FfiCode ANNOTATION_ON_POINTER_FIELD = FfiCode(
     'ANNOTATION_ON_POINTER_FIELD',
     "Fields in a struct class whose type is 'Pointer' should not have any annotations.",
@@ -302,9 +330,9 @@
    */
   static const FfiCode NON_SIZED_TYPE_ARGUMENT = FfiCode(
     'NON_SIZED_TYPE_ARGUMENT',
-    "Type arguments to '{0}' can't have the type '{1}'. They can only be declared as native integer, 'Float', 'Double', 'Pointer', or subtype of 'Struct' or 'Union'.",
+    "Type arguments to '{0}' can't have the type '{1}'. They can only be declared as native integer, 'Float', 'Double', 'Pointer', or subtype of 'Struct', 'Union', or 'AbiSpecificInteger'.",
     correctionMessage:
-        "Try using a native integer, 'Float', 'Double', 'Pointer', or subtype of 'Struct' or 'Union'.",
+        "Try using a native integer, 'Float', 'Double', 'Pointer', or subtype of 'Struct', 'Union', or 'AbiSpecificInteger'.",
   );
 
   /**
diff --git a/pkg/analyzer/lib/src/generated/ffi_verifier.dart b/pkg/analyzer/lib/src/generated/ffi_verifier.dart
index 767d937..69b37a5 100644
--- a/pkg/analyzer/lib/src/generated/ffi_verifier.dart
+++ b/pkg/analyzer/lib/src/generated/ffi_verifier.dart
@@ -16,6 +16,9 @@
 /// used. See 'pkg/vm/lib/transformations/ffi_checks.md' for the specification
 /// of the desired hints.
 class FfiVerifier extends RecursiveAstVisitor<void> {
+  static const _abiSpecificIntegerClassName = 'AbiSpecificInteger';
+  static const _abiSpecificIntegerMappingClassName =
+      'AbiSpecificIntegerMapping';
   static const _allocatorClassName = 'Allocator';
   static const _allocateExtensionMethodName = 'call';
   static const _allocatorExtensionName = 'AllocatorAlloc';
@@ -25,7 +28,7 @@
   static const _opaqueClassName = 'Opaque';
   static const _ffiNativeName = 'FfiNative';
 
-  static const Set<String> _primitiveIntegerNativeTypes = {
+  static const Set<String> _primitiveIntegerNativeTypesFixedSize = {
     'Int8',
     'Int16',
     'Int32',
@@ -34,6 +37,9 @@
     'Uint16',
     'Uint32',
     'Uint64',
+  };
+  static const Set<String> _primitiveIntegerNativeTypes = {
+    ..._primitiveIntegerNativeTypesFixedSize,
     'IntPtr'
   };
 
@@ -85,8 +91,12 @@
           if (className == _structClassName) {
             _validatePackedAnnotation(node.metadata);
           }
+        } else if (className == _abiSpecificIntegerClassName) {
+          _validateAbiSpecificIntegerMappingAnnotation(
+              node.name, node.metadata);
         } else if (className != _allocatorClassName &&
-            className != _opaqueClassName) {
+            className != _opaqueClassName &&
+            className != _abiSpecificIntegerClassName) {
           _errorReporter.reportErrorForNode(
               FfiCode.SUBTYPE_OF_FFI_CLASS_IN_EXTENDS,
               superclass.name,
@@ -452,6 +462,9 @@
     if (nativeType.isArray) {
       return true;
     }
+    if (nativeType.isAbiSpecificIntegerSubtype) {
+      return true;
+    }
     return false;
   }
 
@@ -523,6 +536,9 @@
       if (nativeType.isOpaqueSubtype) {
         return true;
       }
+      if (nativeType.isAbiSpecificIntegerSubtype) {
+        return true;
+      }
       if (allowArray && nativeType.isArray) {
         return _isValidFfiNativeType(nativeType.typeArguments.single,
             allowVoid: false, allowEmptyStruct: false);
@@ -591,10 +607,51 @@
       } else if (_primitiveBoolNativeType == name) {
         return _PrimitiveDartType.bool;
       }
+      if (element.type.returnType.isAbiSpecificIntegerSubtype) {
+        return _PrimitiveDartType.int;
+      }
     }
     return _PrimitiveDartType.none;
   }
 
+  /// Validate that the [annotations] include at most one mapping annotation.
+  void _validateAbiSpecificIntegerMappingAnnotation(
+      AstNode errorNode, NodeList<Annotation> annotations) {
+    final ffiPackedAnnotations = annotations
+        .where((annotation) => annotation.isAbiSpecificIntegerMapping)
+        .toList();
+
+    if (ffiPackedAnnotations.isEmpty) {
+      _errorReporter.reportErrorForNode(
+          FfiCode.ABI_SPECIFIC_INTEGER_MAPPING_MISSING, errorNode);
+      return;
+    }
+
+    if (ffiPackedAnnotations.length > 1) {
+      final extraAnnotations = ffiPackedAnnotations.skip(1);
+      for (final annotation in extraAnnotations) {
+        _errorReporter.reportErrorForNode(
+            FfiCode.ABI_SPECIFIC_INTEGER_MAPPING_EXTRA, annotation.name);
+      }
+    }
+
+    final annotationConstant =
+        ffiPackedAnnotations.first.elementAnnotation?.computeConstantValue();
+    final mappingValues = annotationConstant?.getField('mapping')?.toMapValue();
+    if (mappingValues == null) {
+      return;
+    }
+    for (final nativeType in mappingValues.values) {
+      final nativeTypeName = nativeType?.type?.element?.name;
+      if (nativeTypeName != null &&
+          !_primitiveIntegerNativeTypesFixedSize.contains(nativeTypeName)) {
+        _errorReporter.reportErrorForNode(
+            FfiCode.ABI_SPECIFIC_INTEGER_MAPPING_UNSUPPORTED,
+            ffiPackedAnnotations.first.name);
+      }
+    }
+  }
+
   void _validateAllocate(FunctionExpressionInvocation node) {
     final typeArgumentTypes = node.typeArgumentTypes;
     if (typeArgumentTypes == null || typeArgumentTypes.length != 1) {
@@ -619,7 +676,9 @@
     bool requiredFound = false;
     List<Annotation> extraAnnotations = [];
     for (Annotation annotation in annotations) {
-      if (annotation.element.ffiClass != null) {
+      if (annotation.element.ffiClass != null ||
+          annotation.element?.enclosingElement.isAbiSpecificIntegerSubclass ==
+              true) {
         if (requiredFound) {
           extraAnnotations.add(annotation);
         } else {
@@ -744,7 +803,10 @@
   bool _validateCompatibleNativeType(
       DartType dartType, DartType nativeType, bool checkCovariance) {
     final nativeReturnType = _primitiveNativeType(nativeType);
-    if (nativeReturnType == _PrimitiveDartType.int) {
+    if (nativeReturnType == _PrimitiveDartType.int ||
+        (nativeType is InterfaceType &&
+            nativeType.superclass?.element.name ==
+                _abiSpecificIntegerClassName)) {
       return dartType.isDartCoreInt;
     } else if (nativeReturnType == _PrimitiveDartType.double) {
       return dartType.isDartCoreDouble;
@@ -1197,6 +1259,14 @@
         element.ffiClass != null &&
         element.enclosingElement.name == 'Packed';
   }
+
+  bool get isAbiSpecificIntegerMapping {
+    final element = this.element;
+    return element is ConstructorElement &&
+        element.ffiClass != null &&
+        element.enclosingElement.name ==
+            FfiVerifier._abiSpecificIntegerMappingClassName;
+  }
 }
 
 extension on ElementAnnotation {
@@ -1332,6 +1402,21 @@
     return element is ClassElement && element.supertype.isUnion;
   }
 
+  /// Return `true` if this represents the class `AbiSpecificInteger`.
+  bool get isAbiSpecificInteger {
+    final element = this;
+    return element is ClassElement &&
+        element.name == FfiVerifier._abiSpecificIntegerClassName &&
+        element.isFfiClass;
+  }
+
+  /// Return `true` if this represents a subclass of the class
+  /// `AbiSpecificInteger`.
+  bool get isAbiSpecificIntegerSubclass {
+    final element = this;
+    return element is ClassElement && element.supertype.isAbiSpecificInteger;
+  }
+
   /// If this is a class element from `dart:ffi`, return it.
   ClassElement? get ffiClass {
     var element = this;
@@ -1398,6 +1483,11 @@
     final self = this;
     return self is InterfaceType && self.element.isUnion;
   }
+
+  bool get isAbiSpecificInteger {
+    final self = this;
+    return self is InterfaceType && self.element.isAbiSpecificInteger;
+  }
 }
 
 extension on DartType {
@@ -1467,6 +1557,22 @@
     return false;
   }
 
+  /// Returns `true` iff this is an Abi-specific integer type,
+  /// i.e. a subtype of `AbiSpecificInteger`.
+  bool get isAbiSpecificIntegerSubtype {
+    final self = this;
+    if (self is InterfaceType) {
+      final superType = self.element.supertype;
+      if (superType != null) {
+        final superClassElement = superType.element;
+        return superClassElement.name ==
+                FfiVerifier._abiSpecificIntegerClassName &&
+            superClassElement.isFfiClass;
+      }
+    }
+    return false;
+  }
+
   /// Returns `true` iff this is a opaque type, i.e. a subtype of `Opaque`.
   bool get isOpaqueSubtype {
     final self = this;
diff --git a/pkg/analyzer/lib/src/test_utilities/mock_sdk.dart b/pkg/analyzer/lib/src/test_utilities/mock_sdk.dart
index a7ecd5a..7693ddd 100644
--- a/pkg/analyzer/lib/src/test_utilities/mock_sdk.dart
+++ b/pkg/analyzer/lib/src/test_utilities/mock_sdk.dart
@@ -47,7 +47,7 @@
 
   Future<T> whenComplete(action());
 
-  static Future<List<T>> wait<T>(Iterable<Future<T>> futures, 
+  static Future<List<T>> wait<T>(Iterable<Future<T>> futures,
     {void cleanUp(T successValue)?}) => throw 0;
 }
 
@@ -705,6 +705,10 @@
   const Double();
 }
 
+class IntPtr extends NativeType {
+  const IntPtr();
+}
+
 class Pointer<T extends NativeType> extends NativeType {
   external factory Pointer.fromAddress(int ptr);
 
@@ -789,6 +793,50 @@
   final bool isLeaf;
   const FfiNative(this.nativeName, {this.isLeaf: false});
 }
+
+class Abi {
+  static const androidArm = _androidArm;
+  static const androidArm64 = _androidArm64;
+  static const androidIA32 = _androidIA32;
+
+  static const _androidArm = Abi._(_Architecture.arm, _OS.android);
+  static const _androidArm64 = Abi._(_Architecture.arm64, _OS.android);
+  static const _androidIA32 = Abi._(_Architecture.ia32, _OS.android);
+
+  final _OS _os;
+
+  final _Architecture _architecture;
+
+  const Abi._(this._architecture, this._os);
+}
+
+enum _Architecture {
+  arm,
+  arm64,
+  ia32,
+  x64,
+}
+
+enum _OS {
+  android,
+  fuchsia,
+  ios,
+  linux,
+  macos,
+  windows,
+}
+
+
+class AbiSpecificInteger extends NativeType {
+  const AbiSpecificInteger();
+}
+
+class AbiSpecificIntegerMapping {
+  final Map<Abi, NativeType> mapping;
+
+  const AbiSpecificIntegerMapping(this.mapping);
+}
+
 ''',
   )
 ]);
diff --git a/pkg/analyzer/messages.yaml b/pkg/analyzer/messages.yaml
index 8c2b4be..7ad997e 100644
--- a/pkg/analyzer/messages.yaml
+++ b/pkg/analyzer/messages.yaml
@@ -13775,6 +13775,18 @@
       }
       ```
 FfiCode:
+  ABI_SPECIFIC_INTEGER_MAPPING_EXTRA:
+    problemMessage: "Classes extending 'AbiSpecificInteger' must have exactly one 'AbiSpecificIntegerMapping' annotation specifying the mapping from ABI to a 'NativeType' integer with a fixed size."
+    correctionMessage: Try removing the extra annotation.
+    comment: No parameters.
+  ABI_SPECIFIC_INTEGER_MAPPING_MISSING:
+    problemMessage: "Classes extending 'AbiSpecificInteger' must have exactly one 'AbiSpecificIntegerMapping' annotation specifying the mapping from ABI to a 'NativeType' integer with a fixed size."
+    correctionMessage: Try adding an annotation.
+    comment: No parameters.
+  ABI_SPECIFIC_INTEGER_MAPPING_UNSUPPORTED:
+    problemMessage: "Only mappings to 'Int8', 'Int16', 'Int32', 'Int64', 'Uint8', 'Uint16', 'UInt32', and 'Uint64' are supported."
+    correctionMessage: Try changing the value to 'Int8', 'Int16', 'Int32', 'Int64', 'Uint8', 'Uint16', 'UInt32', or 'Uint64'.
+    comment: No parameters.
   ANNOTATION_ON_POINTER_FIELD:
     problemMessage: "Fields in a struct class whose type is 'Pointer' should not have any annotations."
     correctionMessage: Try removing the annotation.
@@ -13916,8 +13928,8 @@
     correctionMessage: Try changing the input to a positive number.
     comment: No parameters.
   NON_SIZED_TYPE_ARGUMENT:
-    problemMessage: "Type arguments to '{0}' can't have the type '{1}'. They can only be declared as native integer, 'Float', 'Double', 'Pointer', or subtype of 'Struct' or 'Union'."
-    correctionMessage: "Try using a native integer, 'Float', 'Double', 'Pointer', or subtype of 'Struct' or 'Union'."
+    problemMessage: "Type arguments to '{0}' can't have the type '{1}'. They can only be declared as native integer, 'Float', 'Double', 'Pointer', or subtype of 'Struct', 'Union', or 'AbiSpecificInteger'."
+    correctionMessage: "Try using a native integer, 'Float', 'Double', 'Pointer', or subtype of 'Struct', 'Union', or 'AbiSpecificInteger'."
     comment: |-
       Parameters:
       0: the type of the field
diff --git a/pkg/analyzer/test/src/diagnostics/abi_specific_integer_mapping_test.dart b/pkg/analyzer/test/src/diagnostics/abi_specific_integer_mapping_test.dart
new file mode 100644
index 0000000..746ce71
--- /dev/null
+++ b/pkg/analyzer/test/src/diagnostics/abi_specific_integer_mapping_test.dart
@@ -0,0 +1,81 @@
+// 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(AbiSpecificIntegerMappingTest);
+  });
+}
+
+@reflectiveTest
+class AbiSpecificIntegerMappingTest extends PubPackageResolutionTest {
+  test_doubleMapping() async {
+    await assertErrorsInCode(r'''
+import 'dart:ffi';
+@AbiSpecificIntegerMapping({})
+@AbiSpecificIntegerMapping({})
+class UintPtr extends AbiSpecificInteger {
+  const UintPtr();
+}
+''', [
+      error(FfiCode.ABI_SPECIFIC_INTEGER_MAPPING_EXTRA, 51, 25),
+    ]);
+  }
+
+  test_invalidMapping() async {
+    await assertErrorsInCode(r'''
+import 'dart:ffi';
+@AbiSpecificIntegerMapping({
+  Abi.androidArm: Uint32(),
+  Abi.androidArm64: IntPtr(),
+  Abi.androidIA32: UintPtr(),
+})
+class UintPtr extends AbiSpecificInteger {
+  const UintPtr();
+}
+''', [
+      error(FfiCode.ABI_SPECIFIC_INTEGER_MAPPING_UNSUPPORTED, 20, 25),
+    ]);
+  }
+
+  test_noMapping() async {
+    await assertErrorsInCode(r'''
+import 'dart:ffi';
+class UintPtr extends AbiSpecificInteger {
+  const UintPtr();
+}
+''', [
+      error(FfiCode.ABI_SPECIFIC_INTEGER_MAPPING_MISSING, 25, 7),
+    ]);
+  }
+
+  test_singleMapping() async {
+    await assertNoErrorsInCode(r'''
+import 'dart:ffi';
+@AbiSpecificIntegerMapping({})
+class UintPtr extends AbiSpecificInteger {
+  const UintPtr();
+}
+''');
+  }
+
+  test_validMapping() async {
+    await assertNoErrorsInCode(r'''
+import 'dart:ffi';
+@AbiSpecificIntegerMapping({
+  Abi.androidArm: Uint32(),
+  Abi.androidArm64: Uint64(),
+  Abi.androidIA32: Uint32(),
+})
+class UintPtr extends AbiSpecificInteger {
+  const UintPtr();
+}
+''');
+  }
+}
diff --git a/pkg/analyzer/test/src/diagnostics/test_all.dart b/pkg/analyzer/test/src/diagnostics/test_all.dart
index 779326c..4456cef 100644
--- a/pkg/analyzer/test/src/diagnostics/test_all.dart
+++ b/pkg/analyzer/test/src/diagnostics/test_all.dart
@@ -4,6 +4,7 @@
 
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
+import 'abi_specific_integer_mapping_test.dart' as abi_specific_integer_mapping;
 import 'abstract_class_member_test.dart' as abstract_class_member;
 import 'abstract_field_constructor_initializer_test.dart'
     as abstract_field_constructor_initializer;
@@ -721,6 +722,7 @@
 
 main() {
   defineReflectiveSuite(() {
+    abi_specific_integer_mapping.main();
     abstract_class_member.main();
     abstract_field_constructor_initializer.main();
     abstract_field_initializer.main();
diff --git a/pkg/meta/lib/meta.dart b/pkg/meta/lib/meta.dart
index 584fe42..ba14be9 100644
--- a/pkg/meta/lib/meta.dart
+++ b/pkg/meta/lib/meta.dart
@@ -274,7 +274,7 @@
 
 /// Used to annotate a method, field, or getter within a class, mixin, or
 /// extension, or a or top-level getter, variable or function to indicate that
-/// the value obtained by invoking it should be use. A value is considered used
+/// the value obtained by invoking it should be used. A value is considered used
 /// if it is assigned to a variable, passed to a function, or used as the target
 /// of an invocation, or invoked (if the result is itself a function).
 ///
diff --git a/pkg/vm/lib/transformations/ffi/common.dart b/pkg/vm/lib/transformations/ffi/common.dart
index 54ffd5c..42235ff 100644
--- a/pkg/vm/lib/transformations/ffi/common.dart
+++ b/pkg/vm/lib/transformations/ffi/common.dart
@@ -234,6 +234,7 @@
   final Procedure lookupFunctionTearoff;
   final Procedure getNativeFieldFunction;
   final Procedure reachabilityFenceFunction;
+  final Procedure checkAbiSpecificIntegerMappingFunction;
 
   late final InterfaceType nativeFieldWrapperClass1Type;
   late final InterfaceType voidType;
@@ -417,7 +418,9 @@
         getNativeFieldFunction = index.getTopLevelProcedure(
             'dart:nativewrappers', '_getNativeField'),
         reachabilityFenceFunction =
-            index.getTopLevelProcedure('dart:_internal', 'reachabilityFence') {
+            index.getTopLevelProcedure('dart:_internal', 'reachabilityFence'),
+        checkAbiSpecificIntegerMappingFunction = index.getTopLevelProcedure(
+            'dart:ffi', "_checkAbiSpecificIntegerMapping") {
     nativeFieldWrapperClass1Type = nativeFieldWrapperClass1Class.getThisType(
         coreTypes, Nullability.nonNullable);
     voidType = nativeTypesClasses[NativeType.kVoid]!
@@ -453,7 +456,7 @@
   /// [Bool]                               -> [bool]
   /// [Void]                               -> [void]
   /// [Pointer]<T>                         -> [Pointer]<T>
-  /// T extends [Pointer]                  -> T
+  /// T extends [Compound]                 -> T
   /// [Handle]                             -> [Object]
   /// [NativeFunction]<T1 Function(T2, T3) -> S1 Function(S2, S3)
   ///    where DartRepresentationOf(Tn) -> Sn
@@ -535,27 +538,42 @@
   InterfaceType _listOfIntType() => InterfaceType(
       listClass, Nullability.legacy, [coreTypes.intLegacyRawType]);
 
-  ConstantExpression intListConstantExpression(List<int> values) =>
+  ConstantExpression intListConstantExpression(List<int?> values) =>
       ConstantExpression(
-          ListConstant(coreTypes.intLegacyRawType,
-              [for (var v in values) IntConstant(v)]),
+          ListConstant(coreTypes.intLegacyRawType, [
+            for (var v in values)
+              if (v != null) IntConstant(v) else NullConstant()
+          ]),
           _listOfIntType());
 
   /// Expression that queries VM internals at runtime to figure out on which ABI
   /// we are.
-  Expression runtimeBranchOnLayout(Map<Abi, int> values) {
-    return InstanceInvocation(
+  Expression runtimeBranchOnLayout(Map<Abi, int?> values) {
+    final result = InstanceInvocation(
         InstanceAccessKind.Instance,
         intListConstantExpression([
-          for (final abi in Abi.values) values[abi]!,
+          for (final abi in Abi.values) values[abi],
         ]),
         listElementAt.name,
         Arguments([StaticInvocation(abiMethod, Arguments([]))]),
         interfaceTarget: listElementAt,
         functionType: Substitution.fromInterfaceType(_listOfIntType())
             .substituteType(listElementAt.getterType) as FunctionType);
+    if (values.isPartial) {
+      return checkAbiSpecificIntegerMapping(result);
+    }
+    return result;
   }
 
+  Expression checkAbiSpecificIntegerMapping(Expression nullableExpression) =>
+      StaticInvocation(
+        checkAbiSpecificIntegerMappingFunction,
+        Arguments(
+          [nullableExpression],
+          types: [InterfaceType(intClass, Nullability.nonNullable)],
+        ),
+      );
+
   /// Generates an expression that returns a new `Pointer<dartType>` offset
   /// by [offset] from [pointer].
   ///
@@ -819,3 +837,8 @@
   }
   return false;
 }
+
+extension on Map<Abi, Object?> {
+  bool get isPartial =>
+      [for (final abi in Abi.values) this[abi]].contains(null);
+}
diff --git a/pkg/vm/lib/transformations/ffi/definitions.dart b/pkg/vm/lib/transformations/ffi/definitions.dart
index 29ae1d9..fbf2052 100644
--- a/pkg/vm/lib/transformations/ffi/definitions.dart
+++ b/pkg/vm/lib/transformations/ffi/definitions.dart
@@ -2,8 +2,6 @@
 // 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 'dart:math' as math;
-
 import 'package:front_end/src/api_unstable/vm.dart'
     show
         messageFfiPackedAnnotationAlignment,
@@ -33,6 +31,7 @@
 
 import 'abi.dart';
 import 'common.dart';
+import 'native_type_cfe.dart';
 
 /// Checks and elaborates the dart:ffi compounds and their fields.
 ///
@@ -449,9 +448,8 @@
         // This class is invalid, but continue reporting other errors on it.
         success = false;
       } else {
-        final DartType nativeType = InterfaceType(
-            nativeTypesClasses[_getFieldType(nativeTypeAnnos.first)!]!,
-            Nullability.legacy);
+        final DartType nativeType =
+            InterfaceType(nativeTypeAnnos.first, Nullability.legacy);
         final DartType? shouldBeDartType = convertNativeTypeToDartType(
             nativeType,
             allowCompounds: true,
@@ -705,7 +703,6 @@
 
   static const vmFfiStructFields = "vm:ffi:struct-fields";
 
-  // return value is nullable.
   InstanceConstant? _compoundAnnotatedFields(Class node) {
     for (final annotation in node.annotations) {
       if (annotation is ConstantExpression) {
@@ -775,7 +772,6 @@
     return UnionNativeTypeCfe(compoundClass, members);
   }
 
-  // packing is `int?`.
   void _annoteCompoundWithFields(
       Class node, List<NativeTypeCfe> types, int? packing) {
     List<Constant> constants =
@@ -795,8 +791,13 @@
         InterfaceType(pragmaClass, Nullability.nonNullable, [])));
   }
 
-  void _generateMethodsForField(Class node, Field field, NativeTypeCfe type,
-      Map<Abi, int> offsets, bool unalignedAccess, IndexedClass? indexedClass) {
+  void _generateMethodsForField(
+      Class node,
+      Field field,
+      NativeTypeCfe type,
+      Map<Abi, int?> offsets,
+      bool unalignedAccess,
+      IndexedClass? indexedClass) {
     // TODO(johnniwinther): Avoid passing [indexedClass]. When compiling
     // incrementally, [field] should already carry the references from
     // [indexedClass].
@@ -847,7 +848,7 @@
   /// If sizes are not supplied still emits a field so that the use site
   /// transformer can still rewrite to it.
   void _addSizeOfField(Class compound, IndexedClass? indexedClass,
-      [Map<Abi, int>? sizes = null]) {
+      [Map<Abi, int?>? sizes = null]) {
     if (sizes == null) {
       sizes = {for (var abi in Abi.values) abi: 0};
     }
@@ -956,546 +957,3 @@
 
   CompoundField(this.type, this.field, this.getter, this.setter);
 }
-
-/// The layout of a `Struct` or `Union` in one [Abi].
-class CompoundLayout {
-  /// Size of the entire struct or union.
-  final int size;
-
-  /// Alignment of struct or union when nested in a struct.
-  final int alignment;
-
-  /// Offset in bytes for each field, indexed by field number.
-  ///
-  /// Always 0 for unions.
-  final List<int> offsets;
-
-  CompoundLayout(this.size, this.alignment, this.offsets);
-}
-
-/// AST node wrapper for native types.
-///
-/// This algebraic data structure does not stand on its own but refers
-/// intimately to AST nodes such as [Class].
-abstract class NativeTypeCfe {
-  factory NativeTypeCfe(FfiTransformer transformer, DartType dartType,
-      {List<int>? arrayDimensions,
-      Map<Class, NativeTypeCfe> compoundCache = const {}}) {
-    if (transformer.isPrimitiveType(dartType)) {
-      final clazz = (dartType as InterfaceType).classNode;
-      final nativeType = transformer.getType(clazz)!;
-      return PrimitiveNativeTypeCfe(nativeType, clazz);
-    }
-    if (transformer.isPointerType(dartType)) {
-      return PointerNativeTypeCfe();
-    }
-    if (transformer.isCompoundSubtype(dartType)) {
-      final clazz = (dartType as InterfaceType).classNode;
-      if (compoundCache.containsKey(clazz)) {
-        return compoundCache[clazz]!;
-      } else {
-        throw "Class '$clazz' not found in compoundCache.";
-      }
-    }
-    if (transformer.isArrayType(dartType)) {
-      if (arrayDimensions == null) {
-        throw "Must have array dimensions for ArrayType.";
-      }
-      if (arrayDimensions.length == 0) {
-        throw "Must have a size for this array dimension.";
-      }
-      final elementType = transformer.arraySingleElementType(dartType);
-      final elementCfeType =
-          NativeTypeCfe(transformer, elementType, compoundCache: compoundCache);
-      if (elementCfeType is InvalidNativeTypeCfe) {
-        return elementCfeType;
-      }
-      return ArrayNativeTypeCfe.multi(elementCfeType, arrayDimensions);
-    }
-    throw "Invalid type $dartType";
-  }
-
-  /// The size in bytes per [Abi].
-  Map<Abi, int> get size;
-
-  /// The alignment inside structs in bytes per [Abi].
-  ///
-  /// This is not the alignment on stack, this is only calculated in the VM.
-  Map<Abi, int> get alignment;
-
-  /// Generates a Constant representing the type which is consumed by the VM.
-  ///
-  /// Takes [transformer] to be able to lookup classes and methods.
-  ///
-  /// See runtime/vm/compiler/ffi/native_type.cc:NativeType::FromAbstractType.
-  Constant generateConstant(FfiTransformer transformer);
-
-  /// Generates the return statement for a compound field getter with this type.
-  ///
-  /// Takes [transformer] to be able to lookup classes and methods.
-  ReturnStatement generateGetterStatement(DartType dartType, int fileOffset,
-      Map<Abi, int> offsets, bool unalignedAccess, FfiTransformer transformer);
-
-  /// Generates the return statement for a compound field setter with this type.
-  ///
-  /// Takes [transformer] to be able to lookup classes and methods.
-  ReturnStatement generateSetterStatement(
-      DartType dartType,
-      int fileOffset,
-      Map<Abi, int> offsets,
-      bool unalignedAccess,
-      VariableDeclaration argument,
-      FfiTransformer transformer);
-}
-
-class InvalidNativeTypeCfe implements NativeTypeCfe {
-  final String reason;
-
-  InvalidNativeTypeCfe(this.reason);
-
-  @override
-  Map<Abi, int> get alignment => throw reason;
-
-  @override
-  Constant generateConstant(FfiTransformer transformer) => throw reason;
-
-  @override
-  ReturnStatement generateGetterStatement(
-          DartType dartType,
-          int fileOffset,
-          Map<Abi, int> offsets,
-          bool unalignedAccess,
-          FfiTransformer transformer) =>
-      throw reason;
-
-  @override
-  ReturnStatement generateSetterStatement(
-          DartType dartType,
-          int fileOffset,
-          Map<Abi, int> offsets,
-          bool unalignedAccess,
-          VariableDeclaration argument,
-          FfiTransformer transformer) =>
-      throw reason;
-
-  @override
-  Map<Abi, int> get size => throw reason;
-}
-
-class PrimitiveNativeTypeCfe implements NativeTypeCfe {
-  final NativeType nativeType;
-
-  final Class clazz;
-
-  PrimitiveNativeTypeCfe(this.nativeType, this.clazz);
-
-  @override
-  Map<Abi, int> get size {
-    final int size = nativeTypeSizes[nativeType]!;
-    if (size == WORD_SIZE) {
-      return wordSize;
-    }
-    return {for (var abi in Abi.values) abi: size};
-  }
-
-  @override
-  Map<Abi, int> get alignment => {
-        for (var abi in Abi.values)
-          abi: nonSizeAlignment[abi]![nativeType] ?? size[abi]!
-      };
-
-  @override
-  Constant generateConstant(FfiTransformer transformer) =>
-      TypeLiteralConstant(InterfaceType(clazz, Nullability.nonNullable));
-
-  bool get isFloat =>
-      nativeType == NativeType.kFloat || nativeType == NativeType.kDouble;
-
-  bool isUnaligned(Map<Abi, int> offsets) {
-    final alignments = alignment;
-    for (final abi in offsets.keys) {
-      final offset = offsets[abi]!;
-      final alignment = alignments[abi]!;
-      if (offset % alignment != 0) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /// Sample output for `int get x =>`:
-  ///
-  /// ```
-  /// _loadInt8(_typedDataBase, offset);
-  /// ```
-  @override
-  ReturnStatement generateGetterStatement(
-          DartType dartType,
-          int fileOffset,
-          Map<Abi, int> offsets,
-          bool unalignedAccess,
-          FfiTransformer transformer) =>
-      ReturnStatement(StaticInvocation(
-          (unalignedAccess && isFloat
-              ? transformer.loadUnalignedMethods
-              : transformer.loadMethods)[nativeType]!,
-          Arguments([
-            transformer.getCompoundTypedDataBaseField(
-                ThisExpression(), fileOffset),
-            transformer.runtimeBranchOnLayout(offsets)
-          ]))
-        ..fileOffset = fileOffset);
-
-  /// Sample output for `set x(int #v) =>`:
-  ///
-  /// ```
-  /// _storeInt8(_typedDataBase, offset, #v);
-  /// ```
-  @override
-  ReturnStatement generateSetterStatement(
-          DartType dartType,
-          int fileOffset,
-          Map<Abi, int> offsets,
-          bool unalignedAccess,
-          VariableDeclaration argument,
-          FfiTransformer transformer) =>
-      ReturnStatement(StaticInvocation(
-          (unalignedAccess && isFloat
-              ? transformer.storeUnalignedMethods
-              : transformer.storeMethods)[nativeType]!,
-          Arguments([
-            transformer.getCompoundTypedDataBaseField(
-                ThisExpression(), fileOffset),
-            transformer.runtimeBranchOnLayout(offsets),
-            VariableGet(argument)
-          ]))
-        ..fileOffset = fileOffset);
-}
-
-class PointerNativeTypeCfe implements NativeTypeCfe {
-  @override
-  Map<Abi, int> get size => wordSize;
-
-  @override
-  Map<Abi, int> get alignment => wordSize;
-
-  @override
-  Constant generateConstant(FfiTransformer transformer) => TypeLiteralConstant(
-          InterfaceType(transformer.pointerClass, Nullability.nonNullable, [
-        InterfaceType(
-            transformer.pointerClass.superclass!, Nullability.nonNullable)
-      ]));
-
-  /// Sample output for `Pointer<Int8> get x =>`:
-  ///
-  /// ```
-  /// _fromAddress<Int8>(_loadIntPtr(_typedDataBase, offset));
-  /// ```
-  @override
-  ReturnStatement generateGetterStatement(
-          DartType dartType,
-          int fileOffset,
-          Map<Abi, int> offsets,
-          bool unalignedAccess,
-          FfiTransformer transformer) =>
-      ReturnStatement(StaticInvocation(
-          transformer.fromAddressInternal,
-          Arguments([
-            StaticInvocation(
-                transformer.loadMethods[NativeType.kIntptr]!,
-                Arguments([
-                  transformer.getCompoundTypedDataBaseField(
-                      ThisExpression(), fileOffset),
-                  transformer.runtimeBranchOnLayout(offsets)
-                ]))
-              ..fileOffset = fileOffset
-          ], types: [
-            (dartType as InterfaceType).typeArguments.single
-          ]))
-        ..fileOffset = fileOffset);
-
-  /// Sample output for `set x(Pointer<Int8> #v) =>`:
-  ///
-  /// ```
-  /// _storeIntPtr(_typedDataBase, offset, (#v as Pointer<Int8>).address);
-  /// ```
-  @override
-  ReturnStatement generateSetterStatement(
-          DartType dartType,
-          int fileOffset,
-          Map<Abi, int> offsets,
-          bool unalignedAccess,
-          VariableDeclaration argument,
-          FfiTransformer transformer) =>
-      ReturnStatement(StaticInvocation(
-          transformer.storeMethods[NativeType.kIntptr]!,
-          Arguments([
-            transformer.getCompoundTypedDataBaseField(
-                ThisExpression(), fileOffset),
-            transformer.runtimeBranchOnLayout(offsets),
-            InstanceGet(InstanceAccessKind.Instance, VariableGet(argument),
-                transformer.addressGetter.name,
-                interfaceTarget: transformer.addressGetter,
-                resultType: transformer.addressGetter.getterType)
-              ..fileOffset = fileOffset
-          ]))
-        ..fileOffset = fileOffset);
-}
-
-abstract class CompoundNativeTypeCfe implements NativeTypeCfe {
-  final Class clazz;
-
-  final List<NativeTypeCfe> members;
-
-  final Map<Abi, CompoundLayout> layout;
-
-  CompoundNativeTypeCfe._(this.clazz, this.members, this.layout);
-
-  @override
-  Map<Abi, int> get size =>
-      layout.map((abi, layout) => MapEntry(abi, layout.size));
-
-  @override
-  Map<Abi, int> get alignment =>
-      layout.map((abi, layout) => MapEntry(abi, layout.alignment));
-
-  @override
-  Constant generateConstant(FfiTransformer transformer) =>
-      TypeLiteralConstant(InterfaceType(clazz, Nullability.nonNullable));
-
-  /// Sample output for `MyStruct get x =>`:
-  ///
-  /// ```
-  /// MyStruct.#fromTypedDataBase(
-  ///   typedDataBaseOffset(_typedDataBase, offset, size, dartType)
-  /// );
-  /// ```
-  @override
-  ReturnStatement generateGetterStatement(DartType dartType, int fileOffset,
-      Map<Abi, int> offsets, bool unalignedAccess, FfiTransformer transformer) {
-    final constructor = clazz.constructors
-        .firstWhere((c) => c.name == Name("#fromTypedDataBase"));
-
-    return ReturnStatement(ConstructorInvocation(
-        constructor,
-        Arguments([
-          transformer.typedDataBaseOffset(
-              transformer.getCompoundTypedDataBaseField(
-                  ThisExpression(), fileOffset),
-              transformer.runtimeBranchOnLayout(offsets),
-              transformer.runtimeBranchOnLayout(size),
-              dartType,
-              fileOffset)
-        ]))
-      ..fileOffset = fileOffset);
-  }
-
-  /// Sample output for `set x(MyStruct #v) =>`:
-  ///
-  /// ```
-  /// _memCopy(_typedDataBase, offset, #v._typedDataBase, 0, size);
-  /// ```
-  @override
-  ReturnStatement generateSetterStatement(
-          DartType dartType,
-          int fileOffset,
-          Map<Abi, int> offsets,
-          bool unalignedAccess,
-          VariableDeclaration argument,
-          FfiTransformer transformer) =>
-      ReturnStatement(StaticInvocation(
-          transformer.memCopy,
-          Arguments([
-            transformer.getCompoundTypedDataBaseField(
-                ThisExpression(), fileOffset),
-            transformer.runtimeBranchOnLayout(offsets),
-            transformer.getCompoundTypedDataBaseField(
-                VariableGet(argument), fileOffset),
-            ConstantExpression(IntConstant(0)),
-            transformer.runtimeBranchOnLayout(size),
-          ]))
-        ..fileOffset = fileOffset);
-}
-
-class StructNativeTypeCfe extends CompoundNativeTypeCfe {
-  // Nullable int.
-  final int? packing;
-
-  factory StructNativeTypeCfe(Class clazz, List<NativeTypeCfe> members,
-      {int? packing}) {
-    final layout = {
-      for (var abi in Abi.values) abi: _calculateLayout(members, packing, abi)
-    };
-    return StructNativeTypeCfe._(clazz, members, packing, layout);
-  }
-
-  StructNativeTypeCfe._(Class clazz, List<NativeTypeCfe> members, this.packing,
-      Map<Abi, CompoundLayout> layout)
-      : super._(clazz, members, layout);
-
-  // Keep consistent with runtime/vm/compiler/ffi/native_type.cc
-  // NativeStructType::FromNativeTypes.
-  static CompoundLayout _calculateLayout(
-      List<NativeTypeCfe> types, int? packing, Abi abi) {
-    int offset = 0;
-    final offsets = <int>[];
-    int structAlignment = 1;
-    for (int i = 0; i < types.length; i++) {
-      final int size = types[i].size[abi]!;
-      int alignment = types[i].alignment[abi]!;
-      if (packing != null && packing < alignment) {
-        alignment = packing;
-      }
-      if (alignment > 0) {
-        offset = _alignOffset(offset, alignment);
-      }
-      offsets.add(offset);
-      offset += size;
-      structAlignment = math.max(structAlignment, alignment);
-    }
-    final int size = _alignOffset(offset, structAlignment);
-    return CompoundLayout(size, structAlignment, offsets);
-  }
-}
-
-class UnionNativeTypeCfe extends CompoundNativeTypeCfe {
-  factory UnionNativeTypeCfe(Class clazz, List<NativeTypeCfe> members) {
-    final layout = {
-      for (var abi in Abi.values) abi: _calculateLayout(members, abi)
-    };
-    return UnionNativeTypeCfe._(clazz, members, layout);
-  }
-
-  UnionNativeTypeCfe._(
-      Class clazz, List<NativeTypeCfe> members, Map<Abi, CompoundLayout> layout)
-      : super._(clazz, members, layout);
-
-  // Keep consistent with runtime/vm/compiler/ffi/native_type.cc
-  // NativeUnionType::FromNativeTypes.
-  static CompoundLayout _calculateLayout(List<NativeTypeCfe> types, Abi abi) {
-    int unionSize = 1;
-    int unionAlignment = 1;
-    for (int i = 0; i < types.length; i++) {
-      final int size = types[i].size[abi]!;
-      int alignment = types[i].alignment[abi]!;
-      unionSize = math.max(unionSize, size);
-      unionAlignment = math.max(unionAlignment, alignment);
-    }
-    final int size = _alignOffset(unionSize, unionAlignment);
-    return CompoundLayout(size, unionAlignment, List.filled(types.length, 0));
-  }
-}
-
-class ArrayNativeTypeCfe implements NativeTypeCfe {
-  final NativeTypeCfe elementType;
-  final int length;
-
-  ArrayNativeTypeCfe(this.elementType, this.length);
-
-  factory ArrayNativeTypeCfe.multi(
-      NativeTypeCfe elementType, List<int> dimensions) {
-    if (dimensions.length == 1) {
-      return ArrayNativeTypeCfe(elementType, dimensions.single);
-    }
-    return ArrayNativeTypeCfe(
-        ArrayNativeTypeCfe.multi(elementType, dimensions.sublist(1)),
-        dimensions.first);
-  }
-
-  List<int> get dimensions {
-    final elementType = this.elementType;
-    if (elementType is ArrayNativeTypeCfe) {
-      return [length, ...elementType.dimensions];
-    }
-    return [length];
-  }
-
-  List<int> get nestedDimensions => dimensions.sublist(1);
-
-  int get dimensionsFlattened =>
-      dimensions.fold(1, (accumulator, element) => accumulator * element);
-
-  NativeTypeCfe get singleElementType {
-    final elementType = this.elementType;
-    if (elementType is ArrayNativeTypeCfe) {
-      return elementType.singleElementType;
-    }
-    return elementType;
-  }
-
-  @override
-  Map<Abi, int> get size =>
-      elementType.size.map((abi, size) => MapEntry(abi, size * length));
-
-  @override
-  Map<Abi, int> get alignment => elementType.alignment;
-
-  // Note that we flatten multi dimensional arrays.
-  @override
-  Constant generateConstant(FfiTransformer transformer) =>
-      InstanceConstant(transformer.ffiInlineArrayClass.reference, [], {
-        transformer.ffiInlineArrayElementTypeField.fieldReference:
-            singleElementType.generateConstant(transformer),
-        transformer.ffiInlineArrayLengthField.fieldReference:
-            IntConstant(dimensionsFlattened)
-      });
-
-  /// Sample output for `Array<Int8> get x =>`:
-  ///
-  /// ```
-  /// Array<Int8>._(
-  ///   typedDataBaseOffset(_typedDataBase, offset, size, typeArgument)
-  /// );
-  /// ```
-  @override
-  ReturnStatement generateGetterStatement(DartType dartType, int fileOffset,
-      Map<Abi, int> offsets, bool unalignedAccess, FfiTransformer transformer) {
-    InterfaceType typeArgument =
-        (dartType as InterfaceType).typeArguments.single as InterfaceType;
-    return ReturnStatement(ConstructorInvocation(
-        transformer.arrayConstructor,
-        Arguments([
-          transformer.typedDataBaseOffset(
-              transformer.getCompoundTypedDataBaseField(
-                  ThisExpression(), fileOffset),
-              transformer.runtimeBranchOnLayout(offsets),
-              transformer.runtimeBranchOnLayout(size),
-              typeArgument,
-              fileOffset),
-          ConstantExpression(IntConstant(length)),
-          transformer.intListConstantExpression(nestedDimensions)
-        ], types: [
-          typeArgument
-        ]))
-      ..fileOffset = fileOffset);
-  }
-
-  /// Sample output for `set x(Array #v) =>`:
-  ///
-  /// ```
-  /// _memCopy(_typedDataBase, offset, #v._typedDataBase, 0, size);
-  /// ```
-  @override
-  ReturnStatement generateSetterStatement(
-          DartType dartType,
-          int fileOffset,
-          Map<Abi, int> offsets,
-          bool unalignedAccess,
-          VariableDeclaration argument,
-          FfiTransformer transformer) =>
-      ReturnStatement(StaticInvocation(
-          transformer.memCopy,
-          Arguments([
-            transformer.getCompoundTypedDataBaseField(
-                ThisExpression(), fileOffset),
-            transformer.runtimeBranchOnLayout(offsets),
-            transformer.getArrayTypedDataBaseField(
-                VariableGet(argument), fileOffset),
-            ConstantExpression(IntConstant(0)),
-            transformer.runtimeBranchOnLayout(size),
-          ]))
-        ..fileOffset = fileOffset);
-}
-
-int _alignOffset(int offset, int alignment) =>
-    ((offset + alignment - 1) ~/ alignment) * alignment;
diff --git a/pkg/vm/lib/transformations/ffi/native_type_cfe.dart b/pkg/vm/lib/transformations/ffi/native_type_cfe.dart
new file mode 100644
index 0000000..862d1bd
--- /dev/null
+++ b/pkg/vm/lib/transformations/ffi/native_type_cfe.dart
@@ -0,0 +1,627 @@
+// 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 'dart:math' as math;
+
+import 'package:kernel/ast.dart';
+
+import 'abi.dart';
+import 'common.dart';
+
+/// AST node wrapper for native types.
+///
+/// This algebraic data structure does not stand on its own but refers
+/// intimately to AST nodes such as [Class].
+abstract class NativeTypeCfe {
+  factory NativeTypeCfe(FfiTransformer transformer, DartType dartType,
+      {List<int>? arrayDimensions,
+      Map<Class, NativeTypeCfe> compoundCache = const {}}) {
+    if (transformer.isPrimitiveType(dartType)) {
+      final clazz = (dartType as InterfaceType).classNode;
+      final nativeType = transformer.getType(clazz)!;
+      return PrimitiveNativeTypeCfe(nativeType, clazz);
+    }
+    if (transformer.isPointerType(dartType)) {
+      return PointerNativeTypeCfe();
+    }
+    if (transformer.isCompoundSubtype(dartType)) {
+      final clazz = (dartType as InterfaceType).classNode;
+      if (compoundCache.containsKey(clazz)) {
+        return compoundCache[clazz]!;
+      } else {
+        throw "Class '$clazz' not found in compoundCache.";
+      }
+    }
+    if (transformer.isArrayType(dartType)) {
+      if (arrayDimensions == null) {
+        throw "Must have array dimensions for ArrayType.";
+      }
+      if (arrayDimensions.length == 0) {
+        throw "Must have a size for this array dimension.";
+      }
+      final elementType = transformer.arraySingleElementType(dartType);
+      final elementCfeType =
+          NativeTypeCfe(transformer, elementType, compoundCache: compoundCache);
+      if (elementCfeType is InvalidNativeTypeCfe) {
+        return elementCfeType;
+      }
+      return ArrayNativeTypeCfe.multi(elementCfeType, arrayDimensions);
+    }
+    throw "Invalid type $dartType";
+  }
+
+  /// The size in bytes per [Abi].
+  Map<Abi, int?> get size;
+
+  /// The alignment inside structs in bytes per [Abi].
+  ///
+  /// This is not the alignment on stack, this is only calculated in the VM.
+  Map<Abi, int?> get alignment;
+
+  /// Generates a Constant representing the type which is consumed by the VM.
+  ///
+  /// Takes [transformer] to be able to lookup classes and methods.
+  ///
+  /// See runtime/vm/compiler/ffi/native_type.cc:NativeType::FromAbstractType.
+  Constant generateConstant(FfiTransformer transformer);
+
+  /// Generates the return statement for a compound field getter with this type.
+  ///
+  /// Takes [transformer] to be able to lookup classes and methods.
+  ReturnStatement generateGetterStatement(DartType dartType, int fileOffset,
+      Map<Abi, int?> offsets, bool unalignedAccess, FfiTransformer transformer);
+
+  /// Generates the return statement for a compound field setter with this type.
+  ///
+  /// Takes [transformer] to be able to lookup classes and methods.
+  ReturnStatement generateSetterStatement(
+      DartType dartType,
+      int fileOffset,
+      Map<Abi, int?> offsets,
+      bool unalignedAccess,
+      VariableDeclaration argument,
+      FfiTransformer transformer);
+}
+
+class InvalidNativeTypeCfe implements NativeTypeCfe {
+  final String reason;
+
+  InvalidNativeTypeCfe(this.reason);
+
+  @override
+  Map<Abi, int?> get alignment => throw reason;
+
+  @override
+  Constant generateConstant(FfiTransformer transformer) => throw reason;
+
+  @override
+  ReturnStatement generateGetterStatement(
+          DartType dartType,
+          int fileOffset,
+          Map<Abi, int?> offsets,
+          bool unalignedAccess,
+          FfiTransformer transformer) =>
+      throw reason;
+
+  @override
+  ReturnStatement generateSetterStatement(
+          DartType dartType,
+          int fileOffset,
+          Map<Abi, int?> offsets,
+          bool unalignedAccess,
+          VariableDeclaration argument,
+          FfiTransformer transformer) =>
+      throw reason;
+
+  @override
+  Map<Abi, int?> get size => throw reason;
+}
+
+class PrimitiveNativeTypeCfe implements NativeTypeCfe {
+  final NativeType nativeType;
+
+  final Class clazz;
+
+  PrimitiveNativeTypeCfe(this.nativeType, this.clazz);
+
+  @override
+  Map<Abi, int?> get size {
+    final int size = nativeTypeSizes[nativeType]!;
+    if (size == WORD_SIZE) {
+      return wordSize;
+    }
+    return {for (var abi in Abi.values) abi: size};
+  }
+
+  @override
+  Map<Abi, int> get alignment => {
+        for (var abi in Abi.values)
+          abi: nonSizeAlignment[abi]![nativeType] ?? size[abi]!
+      };
+
+  @override
+  Constant generateConstant(FfiTransformer transformer) =>
+      TypeLiteralConstant(InterfaceType(clazz, Nullability.nonNullable));
+
+  bool get isFloat =>
+      nativeType == NativeType.kFloat || nativeType == NativeType.kDouble;
+
+  bool isUnaligned(Map<Abi, int?> offsets) {
+    final alignments = alignment;
+    for (final abi in offsets.keys) {
+      final offset = offsets[abi]!;
+      final alignment = alignments[abi]!;
+      if (offset % alignment != 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /// Sample output for `int get x =>`:
+  ///
+  /// ```
+  /// _loadInt8(_typedDataBase, offset);
+  /// ```
+  @override
+  ReturnStatement generateGetterStatement(
+          DartType dartType,
+          int fileOffset,
+          Map<Abi, int?> offsets,
+          bool unalignedAccess,
+          FfiTransformer transformer) =>
+      ReturnStatement(StaticInvocation(
+          (unalignedAccess && isFloat
+              ? transformer.loadUnalignedMethods
+              : transformer.loadMethods)[nativeType]!,
+          Arguments([
+            transformer.getCompoundTypedDataBaseField(
+                ThisExpression(), fileOffset),
+            transformer.runtimeBranchOnLayout(offsets)
+          ]))
+        ..fileOffset = fileOffset);
+
+  /// Sample output for `set x(int #v) =>`:
+  ///
+  /// ```
+  /// _storeInt8(_typedDataBase, offset, #v);
+  /// ```
+  @override
+  ReturnStatement generateSetterStatement(
+          DartType dartType,
+          int fileOffset,
+          Map<Abi, int?> offsets,
+          bool unalignedAccess,
+          VariableDeclaration argument,
+          FfiTransformer transformer) =>
+      ReturnStatement(StaticInvocation(
+          (unalignedAccess && isFloat
+              ? transformer.storeUnalignedMethods
+              : transformer.storeMethods)[nativeType]!,
+          Arguments([
+            transformer.getCompoundTypedDataBaseField(
+                ThisExpression(), fileOffset),
+            transformer.runtimeBranchOnLayout(offsets),
+            VariableGet(argument)
+          ]))
+        ..fileOffset = fileOffset);
+}
+
+class PointerNativeTypeCfe implements NativeTypeCfe {
+  @override
+  Map<Abi, int?> get size => wordSize;
+
+  @override
+  Map<Abi, int?> get alignment => wordSize;
+
+  @override
+  Constant generateConstant(FfiTransformer transformer) => TypeLiteralConstant(
+          InterfaceType(transformer.pointerClass, Nullability.nonNullable, [
+        InterfaceType(
+            transformer.pointerClass.superclass!, Nullability.nonNullable)
+      ]));
+
+  /// Sample output for `Pointer<Int8> get x =>`:
+  ///
+  /// ```
+  /// _fromAddress<Int8>(_loadIntPtr(_typedDataBase, offset));
+  /// ```
+  @override
+  ReturnStatement generateGetterStatement(
+          DartType dartType,
+          int fileOffset,
+          Map<Abi, int?> offsets,
+          bool unalignedAccess,
+          FfiTransformer transformer) =>
+      ReturnStatement(StaticInvocation(
+          transformer.fromAddressInternal,
+          Arguments([
+            StaticInvocation(
+                transformer.loadMethods[NativeType.kIntptr]!,
+                Arguments([
+                  transformer.getCompoundTypedDataBaseField(
+                      ThisExpression(), fileOffset),
+                  transformer.runtimeBranchOnLayout(offsets)
+                ]))
+              ..fileOffset = fileOffset
+          ], types: [
+            (dartType as InterfaceType).typeArguments.single
+          ]))
+        ..fileOffset = fileOffset);
+
+  /// Sample output for `set x(Pointer<Int8> #v) =>`:
+  ///
+  /// ```
+  /// _storeIntPtr(_typedDataBase, offset, (#v as Pointer<Int8>).address);
+  /// ```
+  @override
+  ReturnStatement generateSetterStatement(
+          DartType dartType,
+          int fileOffset,
+          Map<Abi, int?> offsets,
+          bool unalignedAccess,
+          VariableDeclaration argument,
+          FfiTransformer transformer) =>
+      ReturnStatement(StaticInvocation(
+          transformer.storeMethods[NativeType.kIntptr]!,
+          Arguments([
+            transformer.getCompoundTypedDataBaseField(
+                ThisExpression(), fileOffset),
+            transformer.runtimeBranchOnLayout(offsets),
+            InstanceGet(InstanceAccessKind.Instance, VariableGet(argument),
+                transformer.addressGetter.name,
+                interfaceTarget: transformer.addressGetter,
+                resultType: transformer.addressGetter.getterType)
+              ..fileOffset = fileOffset
+          ]))
+        ..fileOffset = fileOffset);
+}
+
+/// The layout of a `Struct` or `Union` in one [Abi].
+class CompoundLayout {
+  /// Size of the entire struct or union.
+  final int? size;
+
+  /// Alignment of struct or union when nested in a struct.
+  final int? alignment;
+
+  /// Offset in bytes for each field, indexed by field number.
+  ///
+  /// Always 0 for unions.
+  final List<int?> offsets;
+
+  CompoundLayout(this.size, this.alignment, this.offsets);
+}
+
+abstract class CompoundNativeTypeCfe implements NativeTypeCfe {
+  final Class clazz;
+
+  final List<NativeTypeCfe> members;
+
+  final Map<Abi, CompoundLayout> layout;
+
+  CompoundNativeTypeCfe._(this.clazz, this.members, this.layout);
+
+  @override
+  Map<Abi, int?> get size =>
+      layout.map((abi, layout) => MapEntry(abi, layout.size));
+
+  @override
+  Map<Abi, int?> get alignment =>
+      layout.map((abi, layout) => MapEntry(abi, layout.alignment));
+
+  @override
+  Constant generateConstant(FfiTransformer transformer) =>
+      TypeLiteralConstant(InterfaceType(clazz, Nullability.nonNullable));
+
+  /// Sample output for `MyStruct get x =>`:
+  ///
+  /// ```
+  /// MyStruct.#fromTypedDataBase(
+  ///   typedDataBaseOffset(_typedDataBase, offset, size, dartType)
+  /// );
+  /// ```
+  @override
+  ReturnStatement generateGetterStatement(
+      DartType dartType,
+      int fileOffset,
+      Map<Abi, int?> offsets,
+      bool unalignedAccess,
+      FfiTransformer transformer) {
+    final constructor = clazz.constructors
+        .firstWhere((c) => c.name == Name("#fromTypedDataBase"));
+
+    return ReturnStatement(ConstructorInvocation(
+        constructor,
+        Arguments([
+          transformer.typedDataBaseOffset(
+              transformer.getCompoundTypedDataBaseField(
+                  ThisExpression(), fileOffset),
+              transformer.runtimeBranchOnLayout(offsets),
+              transformer.runtimeBranchOnLayout(size),
+              dartType,
+              fileOffset)
+        ]))
+      ..fileOffset = fileOffset);
+  }
+
+  /// Sample output for `set x(MyStruct #v) =>`:
+  ///
+  /// ```
+  /// _memCopy(_typedDataBase, offset, #v._typedDataBase, 0, size);
+  /// ```
+  @override
+  ReturnStatement generateSetterStatement(
+          DartType dartType,
+          int fileOffset,
+          Map<Abi, int?> offsets,
+          bool unalignedAccess,
+          VariableDeclaration argument,
+          FfiTransformer transformer) =>
+      ReturnStatement(StaticInvocation(
+          transformer.memCopy,
+          Arguments([
+            transformer.getCompoundTypedDataBaseField(
+                ThisExpression(), fileOffset),
+            transformer.runtimeBranchOnLayout(offsets),
+            transformer.getCompoundTypedDataBaseField(
+                VariableGet(argument), fileOffset),
+            ConstantExpression(IntConstant(0)),
+            transformer.runtimeBranchOnLayout(size),
+          ]))
+        ..fileOffset = fileOffset);
+}
+
+class StructNativeTypeCfe extends CompoundNativeTypeCfe {
+  // Nullable int.
+  final int? packing;
+
+  factory StructNativeTypeCfe(Class clazz, List<NativeTypeCfe> members,
+      {int? packing}) {
+    final layout = {
+      for (var abi in Abi.values) abi: _calculateLayout(members, packing, abi)
+    };
+    return StructNativeTypeCfe._(clazz, members, packing, layout);
+  }
+
+  StructNativeTypeCfe._(Class clazz, List<NativeTypeCfe> members, this.packing,
+      Map<Abi, CompoundLayout> layout)
+      : super._(clazz, members, layout);
+
+  // Keep consistent with runtime/vm/compiler/ffi/native_type.cc
+  // NativeStructType::FromNativeTypes.
+  static CompoundLayout _calculateLayout(
+      List<NativeTypeCfe> types, int? packing, Abi abi) {
+    int? offset = 0;
+    final offsets = <int?>[];
+    int? structAlignment = 1;
+    for (int i = 0; i < types.length; i++) {
+      final int? size = types[i].size[abi];
+      int? alignment = types[i].alignment[abi];
+      if (packing != null) {
+        alignment = min(packing, alignment);
+      }
+      if (alignment != null && alignment > 0) {
+        offset = offset.align(alignment);
+      }
+      offsets.add(offset);
+      offset += size;
+      structAlignment = max(structAlignment, alignment);
+    }
+    final int? size = offset.align(structAlignment);
+    return CompoundLayout(size, structAlignment, offsets);
+  }
+}
+
+class UnionNativeTypeCfe extends CompoundNativeTypeCfe {
+  factory UnionNativeTypeCfe(Class clazz, List<NativeTypeCfe> members) {
+    final layout = {
+      for (var abi in Abi.values) abi: _calculateLayout(members, abi)
+    };
+    return UnionNativeTypeCfe._(clazz, members, layout);
+  }
+
+  UnionNativeTypeCfe._(
+      Class clazz, List<NativeTypeCfe> members, Map<Abi, CompoundLayout> layout)
+      : super._(clazz, members, layout);
+
+  // Keep consistent with runtime/vm/compiler/ffi/native_type.cc
+  // NativeUnionType::FromNativeTypes.
+  static CompoundLayout _calculateLayout(List<NativeTypeCfe> types, Abi abi) {
+    int? unionSize = 1;
+    int? unionAlignment = 1;
+    for (int i = 0; i < types.length; i++) {
+      final int? size = types[i].size[abi];
+      int? alignment = types[i].alignment[abi];
+      unionSize = max(unionSize, size);
+      unionAlignment = max(unionAlignment, alignment);
+    }
+    final int? size = unionSize.align(unionAlignment);
+    return CompoundLayout(size, unionAlignment, List.filled(types.length, 0));
+  }
+}
+
+class ArrayNativeTypeCfe implements NativeTypeCfe {
+  final NativeTypeCfe elementType;
+  final int length;
+
+  ArrayNativeTypeCfe(this.elementType, this.length);
+
+  factory ArrayNativeTypeCfe.multi(
+      NativeTypeCfe elementType, List<int> dimensions) {
+    if (dimensions.length == 1) {
+      return ArrayNativeTypeCfe(elementType, dimensions.single);
+    }
+    return ArrayNativeTypeCfe(
+        ArrayNativeTypeCfe.multi(elementType, dimensions.sublist(1)),
+        dimensions.first);
+  }
+
+  List<int> get dimensions {
+    final elementType = this.elementType;
+    if (elementType is ArrayNativeTypeCfe) {
+      return [length, ...elementType.dimensions];
+    }
+    return [length];
+  }
+
+  List<int> get nestedDimensions => dimensions.sublist(1);
+
+  int get dimensionsFlattened =>
+      dimensions.fold(1, (accumulator, element) => accumulator * element);
+
+  NativeTypeCfe get singleElementType {
+    final elementType = this.elementType;
+    if (elementType is ArrayNativeTypeCfe) {
+      return elementType.singleElementType;
+    }
+    return elementType;
+  }
+
+  @override
+  Map<Abi, int?> get size =>
+      elementType.size.map((abi, size) => MapEntry(abi, size * length));
+
+  @override
+  Map<Abi, int?> get alignment => elementType.alignment;
+
+  // Note that we flatten multi dimensional arrays.
+  @override
+  Constant generateConstant(FfiTransformer transformer) =>
+      InstanceConstant(transformer.ffiInlineArrayClass.reference, [], {
+        transformer.ffiInlineArrayElementTypeField.fieldReference:
+            singleElementType.generateConstant(transformer),
+        transformer.ffiInlineArrayLengthField.fieldReference:
+            IntConstant(dimensionsFlattened)
+      });
+
+  /// Sample output for `Array<Int8> get x =>`:
+  ///
+  /// ```
+  /// Array<Int8>._(
+  ///   typedDataBaseOffset(_typedDataBase, offset, size, typeArgument)
+  /// );
+  /// ```
+  @override
+  ReturnStatement generateGetterStatement(
+      DartType dartType,
+      int fileOffset,
+      Map<Abi, int?> offsets,
+      bool unalignedAccess,
+      FfiTransformer transformer) {
+    InterfaceType typeArgument =
+        (dartType as InterfaceType).typeArguments.single as InterfaceType;
+    return ReturnStatement(ConstructorInvocation(
+        transformer.arrayConstructor,
+        Arguments([
+          transformer.typedDataBaseOffset(
+              transformer.getCompoundTypedDataBaseField(
+                  ThisExpression(), fileOffset),
+              transformer.runtimeBranchOnLayout(offsets),
+              transformer.runtimeBranchOnLayout(size),
+              typeArgument,
+              fileOffset),
+          ConstantExpression(IntConstant(length)),
+          transformer.intListConstantExpression(nestedDimensions)
+        ], types: [
+          typeArgument
+        ]))
+      ..fileOffset = fileOffset);
+  }
+
+  /// Sample output for `set x(Array #v) =>`:
+  ///
+  /// ```
+  /// _memCopy(_typedDataBase, offset, #v._typedDataBase, 0, size);
+  /// ```
+  @override
+  ReturnStatement generateSetterStatement(
+          DartType dartType,
+          int fileOffset,
+          Map<Abi, int?> offsets,
+          bool unalignedAccess,
+          VariableDeclaration argument,
+          FfiTransformer transformer) =>
+      ReturnStatement(StaticInvocation(
+          transformer.memCopy,
+          Arguments([
+            transformer.getCompoundTypedDataBaseField(
+                ThisExpression(), fileOffset),
+            transformer.runtimeBranchOnLayout(offsets),
+            transformer.getArrayTypedDataBaseField(
+                VariableGet(argument), fileOffset),
+            ConstantExpression(IntConstant(0)),
+            transformer.runtimeBranchOnLayout(size),
+          ]))
+        ..fileOffset = fileOffset);
+}
+
+extension on int? {
+  int? align(int? alignment) =>
+      ((this + alignment - 1) ~/ alignment) * alignment;
+
+  int? operator *(int? other) {
+    final this_ = this;
+    if (this_ == null) {
+      return null;
+    }
+    if (other == null) {
+      return null;
+    }
+    return this_ * other;
+  }
+
+  int? operator +(int? other) {
+    final this_ = this;
+    if (this_ == null) {
+      return null;
+    }
+    if (other == null) {
+      return null;
+    }
+    return this_ + other;
+  }
+
+  int? operator -(int? other) {
+    final this_ = this;
+    if (this_ == null) {
+      return null;
+    }
+    if (other == null) {
+      return null;
+    }
+    return this_ - other;
+  }
+
+  int? operator ~/(int? other) {
+    final this_ = this;
+    if (this_ == null) {
+      return null;
+    }
+    if (other == null) {
+      return null;
+    }
+    return this_ ~/ other;
+  }
+}
+
+int? max(int? a, int? b) {
+  if (a == null) {
+    return null;
+  }
+  if (b == null) {
+    return null;
+  }
+  return math.max(a, b);
+}
+
+int? min(int? a, int? b) {
+  if (a == null) {
+    return null;
+  }
+  if (b == null) {
+    return null;
+  }
+  return math.min(a, b);
+}
diff --git a/runtime/vm/compiler/ffi/marshaller.cc b/runtime/vm/compiler/ffi/marshaller.cc
index dbaff91..6cf5ece 100644
--- a/runtime/vm/compiler/ffi/marshaller.cc
+++ b/runtime/vm/compiler/ffi/marshaller.cc
@@ -25,9 +25,10 @@
 const intptr_t kNativeParamsStartAt = 1;
 
 // Representations of the arguments and return value of a C signature function.
-static const NativeFunctionType& NativeFunctionSignature(
+const NativeFunctionType* NativeFunctionTypeFromFunctionType(
     Zone* zone,
-    const FunctionType& c_signature) {
+    const FunctionType& c_signature,
+    const char** error) {
   ASSERT(c_signature.NumOptionalParameters() == 0);
   ASSERT(c_signature.NumOptionalPositionalParameters() == 0);
 
@@ -38,29 +39,41 @@
   for (intptr_t i = 0; i < num_arguments; i++) {
     AbstractType& arg_type = AbstractType::Handle(
         zone, c_signature.ParameterTypeAt(i + kNativeParamsStartAt));
-    const auto& rep = NativeType::FromAbstractType(zone, arg_type);
-    argument_representations.Add(&rep);
+    const auto rep = NativeType::FromAbstractType(zone, arg_type, error);
+    if (*error != nullptr) {
+      return nullptr;
+    }
+    argument_representations.Add(rep);
   }
 
   const auto& result_type =
       AbstractType::Handle(zone, c_signature.result_type());
-  const auto& result_representation =
-      NativeType::FromAbstractType(zone, result_type);
+  const auto result_representation =
+      NativeType::FromAbstractType(zone, result_type, error);
+  if (*error != nullptr) {
+    return nullptr;
+  }
 
-  const auto& result = *new (zone) NativeFunctionType(argument_representations,
-                                                      result_representation);
+  const auto result = new (zone)
+      NativeFunctionType(argument_representations, *result_representation);
   return result;
 }
 
-BaseMarshaller::BaseMarshaller(Zone* zone, const Function& dart_signature)
-    : zone_(zone),
-      dart_signature_(dart_signature),
-      c_signature_(
-          FunctionType::ZoneHandle(zone, dart_signature.FfiCSignature())),
-      native_calling_convention_(NativeCallingConvention::FromSignature(
-          zone,
-          NativeFunctionSignature(zone_, c_signature_))) {
-  ASSERT(dart_signature_.IsZoneHandle());
+CallMarshaller* CallMarshaller::FromFunction(Zone* zone,
+                                             const Function& function,
+                                             const char** error) {
+  ASSERT(function.IsZoneHandle());
+  const auto& c_signature =
+      FunctionType::ZoneHandle(zone, function.FfiCSignature());
+  const auto native_function_signature =
+      NativeFunctionTypeFromFunctionType(zone, c_signature, error);
+  if (*error != nullptr) {
+    return nullptr;
+  }
+  const auto& native_calling_convention =
+      NativeCallingConvention::FromSignature(zone, *native_function_signature);
+  return new (zone)
+      CallMarshaller(zone, function, c_signature, native_calling_convention);
 }
 
 AbstractTypePtr BaseMarshaller::CType(intptr_t arg_index) const {
@@ -72,6 +85,27 @@
   return c_signature_.ParameterTypeAt(arg_index + kNativeParamsStartAt);
 }
 
+// Keep consistent with Function::FfiCSignatureReturnsStruct.
+bool BaseMarshaller::IsCompound(intptr_t arg_index) const {
+  const auto& type = AbstractType::Handle(zone_, CType(arg_index));
+  if (IsFfiTypeClassId(type.type_class_id())) {
+    return false;
+  }
+#ifdef DEBUG
+  const auto& cls = Class::Handle(this->zone_, type.type_class());
+  const auto& superClass = Class::Handle(this->zone_, cls.SuperClass());
+  // TODO(http://dartbug.com/42563): Implement AbiSpecificInt.
+  const bool is_struct =
+      String::Handle(this->zone_, superClass.UserVisibleName())
+          .Equals(Symbols::Struct());
+  const bool is_union =
+      String::Handle(this->zone_, superClass.UserVisibleName())
+          .Equals(Symbols::Union());
+  RELEASE_ASSERT(is_struct || is_union);
+#endif
+  return true;
+}
+
 bool BaseMarshaller::ContainsHandles() const {
   return dart_signature_.FfiCSignatureContainsHandles();
 }
@@ -574,13 +608,26 @@
   intptr_t argument_slots_required_ = 0;
 };
 
-CallbackMarshaller::CallbackMarshaller(Zone* zone,
-                                       const Function& dart_signature)
-    : BaseMarshaller(zone, dart_signature),
-      callback_locs_(CallbackArgumentTranslator::TranslateArgumentLocations(
-          zone_,
-          native_calling_convention_.argument_locations(),
-          native_calling_convention_.return_location())) {}
+CallbackMarshaller* CallbackMarshaller::FromFunction(Zone* zone,
+                                                     const Function& function,
+                                                     const char** error) {
+  ASSERT(function.IsZoneHandle());
+  const auto& c_signature =
+      FunctionType::ZoneHandle(zone, function.FfiCSignature());
+  const auto native_function_signature =
+      NativeFunctionTypeFromFunctionType(zone, c_signature, error);
+  if (*error != nullptr) {
+    return nullptr;
+  }
+  const auto& native_calling_convention =
+      NativeCallingConvention::FromSignature(zone, *native_function_signature);
+  const auto& callback_locs =
+      CallbackArgumentTranslator::TranslateArgumentLocations(
+          zone, native_calling_convention.argument_locations(),
+          native_calling_convention.return_location());
+  return new (zone) CallbackMarshaller(
+      zone, function, c_signature, native_calling_convention, callback_locs);
+}
 
 const NativeLocation& CallbackMarshaller::NativeLocationOfNativeParameter(
     intptr_t def_index) const {
diff --git a/runtime/vm/compiler/ffi/marshaller.h b/runtime/vm/compiler/ffi/marshaller.h
index fc29f67..b7607e9 100644
--- a/runtime/vm/compiler/ffi/marshaller.h
+++ b/runtime/vm/compiler/ffi/marshaller.h
@@ -28,6 +28,13 @@
 // Values below 0 index result (result might be multiple if composite).
 const intptr_t kResultIndex = -1;
 
+// Inspects the function signature and transitively any class and field
+// definitions and annotations.
+const NativeFunctionType* NativeFunctionTypeFromFunctionType(
+    Zone* zone,
+    const FunctionType& c_signature,
+    const char** error);
+
 // Provides the mapping from the native calling convention to the Dart calling
 // convention.
 //
@@ -114,11 +121,7 @@
            kFfiBoolCid;
   }
 
-  bool IsCompound(intptr_t arg_index) const {
-    const auto& type = AbstractType::Handle(zone_, CType(arg_index));
-    const bool predefined = IsFfiTypeClassId(type.type_class_id());
-    return !predefined;
-  }
+  bool IsCompound(intptr_t arg_index) const;
 
   // Treated as a null constant in Dart.
   bool IsVoid(intptr_t arg_index) const {
@@ -131,7 +134,14 @@
   StringPtr function_name() const { return dart_signature_.name(); }
 
  protected:
-  BaseMarshaller(Zone* zone, const Function& dart_signature);
+  BaseMarshaller(Zone* zone,
+                 const Function& dart_signature,
+                 const FunctionType& c_signature,
+                 const NativeCallingConvention& native_calling_convention)
+      : zone_(zone),
+        dart_signature_(dart_signature),
+        c_signature_(c_signature),
+        native_calling_convention_(native_calling_convention) {}
 
   ~BaseMarshaller() {}
 
@@ -145,8 +155,18 @@
 
 class CallMarshaller : public BaseMarshaller {
  public:
-  CallMarshaller(Zone* zone, const Function& dart_signature)
-      : BaseMarshaller(zone, dart_signature) {}
+  static CallMarshaller* FromFunction(Zone* zone,
+                                      const Function& function,
+                                      const char** error);
+
+  CallMarshaller(Zone* zone,
+                 const Function& dart_signature,
+                 const FunctionType& c_signature,
+                 const NativeCallingConvention& native_calling_convention)
+      : BaseMarshaller(zone,
+                       dart_signature,
+                       c_signature,
+                       native_calling_convention) {}
 
   virtual Representation RepInFfiCall(intptr_t def_index_global) const;
 
@@ -173,7 +193,20 @@
 
 class CallbackMarshaller : public BaseMarshaller {
  public:
-  CallbackMarshaller(Zone* zone, const Function& dart_signature);
+  static CallbackMarshaller* FromFunction(Zone* zone,
+                                          const Function& function,
+                                          const char** error);
+
+  CallbackMarshaller(Zone* zone,
+                     const Function& dart_signature,
+                     const FunctionType& c_signature,
+                     const NativeCallingConvention& native_calling_convention,
+                     const NativeLocations& callback_locs)
+      : BaseMarshaller(zone,
+                       dart_signature,
+                       c_signature,
+                       native_calling_convention),
+        callback_locs_(callback_locs) {}
 
   virtual Representation RepInFfiCall(intptr_t def_index_global) const;
 
diff --git a/runtime/vm/compiler/ffi/native_type.cc b/runtime/vm/compiler/ffi/native_type.cc
index 6dfaeb7..bf4d452a 100644
--- a/runtime/vm/compiler/ffi/native_type.cc
+++ b/runtime/vm/compiler/ffi/native_type.cc
@@ -7,6 +7,7 @@
 #include "platform/assert.h"
 #include "platform/globals.h"
 #include "vm/class_id.h"
+#include "vm/compiler/ffi/abi.h"
 #include "vm/constants.h"
 #include "vm/zone_text_buffer.h"
 
@@ -386,53 +387,22 @@
   }
 }
 
-NativeType& NativeType::FromTypedDataClassId(Zone* zone, classid_t class_id) {
+const NativeType& NativeType::FromTypedDataClassId(Zone* zone,
+                                                   classid_t class_id) {
   ASSERT(IsFfiPredefinedClassId(class_id));
   const auto fundamental_rep = TypeRepresentation(class_id);
   return *new (zone) NativePrimitiveType(fundamental_rep);
 }
 
 #if !defined(FFI_UNIT_TESTS)
-NativeType& NativeType::FromAbstractType(Zone* zone, const AbstractType& type) {
-  const classid_t class_id = type.type_class_id();
-  if (IsFfiPredefinedClassId(class_id)) {
-    return NativeType::FromTypedDataClassId(zone, class_id);
-  }
-
-  // User-defined structs.
-  const auto& cls = Class::Handle(zone, type.type_class());
-  const auto& superClass = Class::Handle(zone, cls.SuperClass());
-  const bool is_struct = String::Handle(zone, superClass.UserVisibleName())
-                             .Equals(Symbols::Struct());
-  ASSERT(is_struct || String::Handle(zone, superClass.UserVisibleName())
-                          .Equals(Symbols::Union()));
-
-  auto& pragmas = Object::Handle(zone);
-  Library::FindPragma(dart::Thread::Current(), /*only_core=*/false, cls,
-                      Symbols::vm_ffi_struct_fields(), /*multiple=*/true,
-                      &pragmas);
-  ASSERT(!pragmas.IsNull());
-  ASSERT(pragmas.IsGrowableObjectArray());
-  const auto& pragmas_array = GrowableObjectArray::Cast(pragmas);
-  auto& pragma = Instance::Handle(zone);
-  auto& clazz = Class::Handle(zone);
-  auto& library = Library::Handle(zone);
-  for (intptr_t i = 0; i < pragmas_array.Length(); i++) {
-    pragma ^= pragmas_array.At(i);
-    clazz ^= pragma.clazz();
-    library ^= clazz.library();
-    if (String::Handle(zone, clazz.UserVisibleName())
-            .Equals(Symbols::FfiStructLayout()) &&
-        String::Handle(zone, library.url()).Equals(Symbols::DartFfi())) {
-      break;
-    }
-  }
-
+static const NativeType* CompoundFromPragma(Zone* zone,
+                                            const Instance& pragma,
+                                            bool is_struct,
+                                            const char** error) {
   const auto& struct_layout = pragma;
-  const auto& struct_layout_class = clazz;
-  ASSERT(String::Handle(zone, struct_layout_class.UserVisibleName())
+  const auto& clazz = Class::Handle(zone, struct_layout.clazz());
+  ASSERT(String::Handle(zone, clazz.UserVisibleName())
              .Equals(Symbols::FfiStructLayout()));
-  ASSERT(String::Handle(zone, library.url()).Equals(Symbols::DartFfi()));
   const auto& struct_layout_fields = Array::Handle(zone, clazz.fields());
   ASSERT(struct_layout_fields.Length() == 2);
   const auto& types_field =
@@ -460,8 +430,11 @@
       // Subtype of NativeType: Struct, native integer or native float.
       field_type ^= field_types.At(i);
       const auto& field_native_type =
-          NativeType::FromAbstractType(zone, field_type);
-      field_native_types.Add(&field_native_type);
+          NativeType::FromAbstractType(zone, field_type, error);
+      if (*error != nullptr) {
+        return nullptr;
+      }
+      field_native_types.Add(field_native_type);
     } else {
       // Inline array.
       const auto& struct_layout_array_class =
@@ -482,20 +455,67 @@
                  .Equals(Symbols::Length()));
       const auto& length = Smi::Handle(
           zone, Smi::RawCast(field_instance.GetField(length_field)));
-      const auto& element_type = NativeType::FromAbstractType(zone, field_type);
-      const auto& field_native_type =
-          *new (zone) NativeArrayType(element_type, length.AsInt64Value());
-      field_native_types.Add(&field_native_type);
+      const auto element_type =
+          NativeType::FromAbstractType(zone, field_type, error);
+      if (*error != nullptr) {
+        return nullptr;
+      }
+      const auto field_native_type =
+          new (zone) NativeArrayType(*element_type, length.AsInt64Value());
+      field_native_types.Add(field_native_type);
     }
   }
 
   if (is_struct) {
-    return NativeStructType::FromNativeTypes(zone, field_native_types,
-                                             member_packing);
+    return &NativeStructType::FromNativeTypes(zone, field_native_types,
+                                              member_packing);
   } else {
-    return NativeUnionType::FromNativeTypes(zone, field_native_types);
+    return &NativeUnionType::FromNativeTypes(zone, field_native_types);
   }
 }
+
+// TODO(http://dartbug.com/42563): Implement AbiSpecificInt.
+const NativeType* NativeType::FromAbstractType(Zone* zone,
+                                               const AbstractType& type,
+                                               const char** error) {
+  const classid_t class_id = type.type_class_id();
+  if (IsFfiPredefinedClassId(class_id)) {
+    return &NativeType::FromTypedDataClassId(zone, class_id);
+  }
+
+  // User-defined structs or unions.
+  const auto& cls = Class::Handle(zone, type.type_class());
+  const auto& superClass = Class::Handle(zone, cls.SuperClass());
+  const bool is_struct = String::Handle(zone, superClass.UserVisibleName())
+                             .Equals(Symbols::Struct());
+  const bool is_union = String::Handle(zone, superClass.UserVisibleName())
+                            .Equals(Symbols::Union());
+  RELEASE_ASSERT(is_struct || is_union);
+
+  auto& pragmas = Object::Handle(zone);
+  String& pragma_name = String::Handle(zone);
+  pragma_name = Symbols::vm_ffi_struct_fields().ptr();
+  Library::FindPragma(dart::Thread::Current(), /*only_core=*/false, cls,
+                      pragma_name, /*multiple=*/true, &pragmas);
+  ASSERT(!pragmas.IsNull());
+  ASSERT(pragmas.IsGrowableObjectArray());
+  const auto& pragmas_array = GrowableObjectArray::Cast(pragmas);
+  auto& pragma = Instance::Handle(zone);
+  auto& clazz = Class::Handle(zone);
+  auto& library = Library::Handle(zone);
+  const String& class_symbol = Symbols::FfiStructLayout();
+  for (intptr_t i = 0; i < pragmas_array.Length(); i++) {
+    pragma ^= pragmas_array.At(i);
+    clazz ^= pragma.clazz();
+    library ^= clazz.library();
+    if (String::Handle(zone, clazz.UserVisibleName()).Equals(class_symbol) &&
+        String::Handle(zone, library.url()).Equals(Symbols::DartFfi())) {
+      break;
+    }
+  }
+
+  return CompoundFromPragma(zone, pragma, is_struct, error);
+}
 #endif
 
 #if !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
diff --git a/runtime/vm/compiler/ffi/native_type.h b/runtime/vm/compiler/ffi/native_type.h
index 2ee284a..f60fea6 100644
--- a/runtime/vm/compiler/ffi/native_type.h
+++ b/runtime/vm/compiler/ffi/native_type.h
@@ -57,9 +57,11 @@
 class NativeType : public ZoneAllocated {
  public:
 #if !defined(FFI_UNIT_TESTS)
-  static NativeType& FromAbstractType(Zone* zone, const AbstractType& type);
+  static const NativeType* FromAbstractType(Zone* zone,
+                                            const AbstractType& type,
+                                            const char** error);
 #endif
-  static NativeType& FromTypedDataClassId(Zone* zone, classid_t class_id);
+  static const NativeType& FromTypedDataClassId(Zone* zone, classid_t class_id);
 
 #if !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
   static NativePrimitiveType& FromUnboxedRepresentation(Zone* zone,
diff --git a/runtime/vm/compiler/ffi/native_type_vm_test.cc b/runtime/vm/compiler/ffi/native_type_vm_test.cc
index 196ae4c..50a1e07 100644
--- a/runtime/vm/compiler/ffi/native_type_vm_test.cc
+++ b/runtime/vm/compiler/ffi/native_type_vm_test.cc
@@ -17,7 +17,9 @@
   const auto& ffi_library = Library::Handle(Library::FfiLibrary());
   const auto& int8_class = Class::Handle(GetClass(ffi_library, "Int8"));
   const auto& int8_type = Type::Handle(int8_class.DeclarationType());
-  const auto& native_type = NativeType::FromAbstractType(Z, int8_type);
+  const char* error = nullptr;
+  const auto& native_type = *NativeType::FromAbstractType(Z, int8_type, &error);
+  EXPECT_NULLPTR(error);
 
   EXPECT_EQ(1, native_type.SizeInBytes());
   EXPECT_STREQ("int8", native_type.ToCString());
@@ -36,7 +38,10 @@
   const auto& ffi_library = Library::Handle(Library::FfiLibrary());
   const auto& bool_class = Class::Handle(GetClass(ffi_library, "Bool"));
   const auto& bool_type = Type::Handle(bool_class.DeclarationType());
-  const auto& bool_native_type = NativeType::FromAbstractType(Z, bool_type);
+  const char* error = nullptr;
+  const auto& bool_native_type =
+      *NativeType::FromAbstractType(Z, bool_type, &error);
+  EXPECT_NULLPTR(error);
 
   const auto& uint8_native_type = *new (Z) NativePrimitiveType(kUint8);
 
@@ -67,8 +72,10 @@
   const auto& struct_class = Class::Handle(GetClass(root_library, "MyStruct"));
   const auto& struct_type = Type::Handle(struct_class.DeclarationType());
 
+  const char* error = nullptr;
   const auto& native_type =
-      NativeType::FromAbstractType(Z, struct_type).AsCompound();
+      NativeType::FromAbstractType(Z, struct_type, &error)->AsCompound();
+  EXPECT_NULLPTR(error);
 
   EXPECT_EQ(2, native_type.members().length());
 
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc
index 9b0e7cf..2b7346a 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.cc
+++ b/runtime/vm/compiler/frontend/kernel_to_il.cc
@@ -838,20 +838,46 @@
     case MethodRecognizer::kTypedData_Float32x4Array_factory:
     case MethodRecognizer::kTypedData_Int32x4Array_factory:
     case MethodRecognizer::kTypedData_Float64x2Array_factory:
-#define FFI_LOAD_STORE(type)                                                   \
-  case MethodRecognizer::kFfiLoad##type:                                       \
-  case MethodRecognizer::kFfiStore##type:
-    CLASS_LIST_FFI_NUMERIC(FFI_LOAD_STORE)
-    FFI_LOAD_STORE(FloatUnaligned)
-    FFI_LOAD_STORE(DoubleUnaligned)
-    FFI_LOAD_STORE(Pointer)
-#undef FFI_LOAD_STORE
+    case MethodRecognizer::kFfiLoadInt8:
+    case MethodRecognizer::kFfiLoadInt16:
+    case MethodRecognizer::kFfiLoadInt32:
+    case MethodRecognizer::kFfiLoadInt64:
+    case MethodRecognizer::kFfiLoadUint8:
+    case MethodRecognizer::kFfiLoadUint16:
+    case MethodRecognizer::kFfiLoadUint32:
+    case MethodRecognizer::kFfiLoadUint64:
+    case MethodRecognizer::kFfiLoadIntPtr:
+    case MethodRecognizer::kFfiLoadFloat:
+    case MethodRecognizer::kFfiLoadFloatUnaligned:
+    case MethodRecognizer::kFfiLoadDouble:
+    case MethodRecognizer::kFfiLoadDoubleUnaligned:
+    case MethodRecognizer::kFfiLoadPointer:
+    case MethodRecognizer::kFfiStoreInt8:
+    case MethodRecognizer::kFfiStoreInt16:
+    case MethodRecognizer::kFfiStoreInt32:
+    case MethodRecognizer::kFfiStoreInt64:
+    case MethodRecognizer::kFfiStoreUint8:
+    case MethodRecognizer::kFfiStoreUint16:
+    case MethodRecognizer::kFfiStoreUint32:
+    case MethodRecognizer::kFfiStoreUint64:
+    case MethodRecognizer::kFfiStoreIntPtr:
+    case MethodRecognizer::kFfiStoreFloat:
+    case MethodRecognizer::kFfiStoreFloatUnaligned:
+    case MethodRecognizer::kFfiStoreDouble:
+    case MethodRecognizer::kFfiStoreDoubleUnaligned:
+    case MethodRecognizer::kFfiStorePointer:
     case MethodRecognizer::kFfiFromAddress:
     case MethodRecognizer::kFfiGetAddress:
-#define FFI_AS_EXTERNAL_TYPED_DATA(type)                                       \
-  case MethodRecognizer::kFfiAsExternalTypedData##type:
-    CLASS_LIST_FFI_NUMERIC_FIXED_SIZE(FFI_AS_EXTERNAL_TYPED_DATA)
-#undef FFI_AS_EXTERNAL_TYPED_DATA
+    case MethodRecognizer::kFfiAsExternalTypedDataInt8:
+    case MethodRecognizer::kFfiAsExternalTypedDataInt16:
+    case MethodRecognizer::kFfiAsExternalTypedDataInt32:
+    case MethodRecognizer::kFfiAsExternalTypedDataInt64:
+    case MethodRecognizer::kFfiAsExternalTypedDataUint8:
+    case MethodRecognizer::kFfiAsExternalTypedDataUint16:
+    case MethodRecognizer::kFfiAsExternalTypedDataUint32:
+    case MethodRecognizer::kFfiAsExternalTypedDataUint64:
+    case MethodRecognizer::kFfiAsExternalTypedDataFloat:
+    case MethodRecognizer::kFfiAsExternalTypedDataDouble:
     case MethodRecognizer::kGetNativeField:
     case MethodRecognizer::kObjectEquals:
     case MethodRecognizer::kStringBaseLength:
@@ -1331,13 +1357,20 @@
       ASSERT_EQUAL(function.NumParameters(), 0);
       body += IntConstant(static_cast<int64_t>(compiler::ffi::TargetAbi()));
       break;
-#define FFI_LOAD(type) case MethodRecognizer::kFfiLoad##type:
-    CLASS_LIST_FFI_NUMERIC(FFI_LOAD)
-    FFI_LOAD(FloatUnaligned)
-    FFI_LOAD(DoubleUnaligned)
-    FFI_LOAD(Pointer)
-#undef FFI_LOAD
-    {
+    case MethodRecognizer::kFfiLoadInt8:
+    case MethodRecognizer::kFfiLoadInt16:
+    case MethodRecognizer::kFfiLoadInt32:
+    case MethodRecognizer::kFfiLoadInt64:
+    case MethodRecognizer::kFfiLoadUint8:
+    case MethodRecognizer::kFfiLoadUint16:
+    case MethodRecognizer::kFfiLoadUint32:
+    case MethodRecognizer::kFfiLoadUint64:
+    case MethodRecognizer::kFfiLoadIntPtr:
+    case MethodRecognizer::kFfiLoadFloat:
+    case MethodRecognizer::kFfiLoadFloatUnaligned:
+    case MethodRecognizer::kFfiLoadDouble:
+    case MethodRecognizer::kFfiLoadDoubleUnaligned:
+    case MethodRecognizer::kFfiLoadPointer: {
       const classid_t ffi_type_arg_cid =
           compiler::ffi::RecognizedMethodTypeArgCid(kind);
       const AlignmentType alignment =
@@ -1403,13 +1436,20 @@
       }
       body += DropTempsPreserveTop(1);  // Drop [arg_offset].
     } break;
-#define FFI_STORE(type) case MethodRecognizer::kFfiStore##type:
-    CLASS_LIST_FFI_NUMERIC(FFI_STORE)
-    FFI_STORE(FloatUnaligned)
-    FFI_STORE(DoubleUnaligned)
-    FFI_STORE(Pointer)
-#undef FFI_STORE
-    {
+    case MethodRecognizer::kFfiStoreInt8:
+    case MethodRecognizer::kFfiStoreInt16:
+    case MethodRecognizer::kFfiStoreInt32:
+    case MethodRecognizer::kFfiStoreInt64:
+    case MethodRecognizer::kFfiStoreUint8:
+    case MethodRecognizer::kFfiStoreUint16:
+    case MethodRecognizer::kFfiStoreUint32:
+    case MethodRecognizer::kFfiStoreUint64:
+    case MethodRecognizer::kFfiStoreIntPtr:
+    case MethodRecognizer::kFfiStoreFloat:
+    case MethodRecognizer::kFfiStoreFloatUnaligned:
+    case MethodRecognizer::kFfiStoreDouble:
+    case MethodRecognizer::kFfiStoreDoubleUnaligned:
+    case MethodRecognizer::kFfiStorePointer: {
       const classid_t ffi_type_arg_cid =
           compiler::ffi::RecognizedMethodTypeArgCid(kind);
       const AlignmentType alignment =
@@ -1519,11 +1559,16 @@
       body += Constant(Bool::False());
 #endif  // defined(ARCH_IS_64_BIT)
     } break;
-#define FFI_AS_EXTERNAL_TYPED_DATA(type)                                       \
-  case MethodRecognizer::kFfiAsExternalTypedData##type:
-    CLASS_LIST_FFI_NUMERIC_FIXED_SIZE(FFI_AS_EXTERNAL_TYPED_DATA)
-#undef FFI_AS_EXTERNAL_TYPED_DATA
-    {
+    case MethodRecognizer::kFfiAsExternalTypedDataInt8:
+    case MethodRecognizer::kFfiAsExternalTypedDataInt16:
+    case MethodRecognizer::kFfiAsExternalTypedDataInt32:
+    case MethodRecognizer::kFfiAsExternalTypedDataInt64:
+    case MethodRecognizer::kFfiAsExternalTypedDataUint8:
+    case MethodRecognizer::kFfiAsExternalTypedDataUint16:
+    case MethodRecognizer::kFfiAsExternalTypedDataUint32:
+    case MethodRecognizer::kFfiAsExternalTypedDataUint64:
+    case MethodRecognizer::kFfiAsExternalTypedDataFloat:
+    case MethodRecognizer::kFfiAsExternalTypedDataDouble: {
       const classid_t ffi_type_arg_cid =
           compiler::ffi::RecognizedMethodTypeArgCid(kind);
       const classid_t external_typed_data_cid =
@@ -1531,8 +1576,8 @@
 
       auto class_table = thread_->isolate_group()->class_table();
       ASSERT(class_table->HasValidClassAt(external_typed_data_cid));
-      const auto& typed_data_class = Class::ZoneHandle(
-          H.zone(), class_table->At(external_typed_data_cid));
+      const auto& typed_data_class =
+          Class::ZoneHandle(H.zone(), class_table->At(external_typed_data_cid));
 
       // We assume that the caller has checked that the arguments are non-null
       // and length is in the range [0, kSmiMax/elementSize].
@@ -4443,7 +4488,12 @@
   Fragment function_body(instruction_cursor);
   function_body += CheckStackOverflowInPrologue(function.token_pos());
 
-  const auto& marshaller = *new (Z) compiler::ffi::CallMarshaller(Z, function);
+  const char* error = nullptr;
+  const auto marshaller_ptr =
+      compiler::ffi::CallMarshaller::FromFunction(Z, function, &error);
+  RELEASE_ASSERT(error == nullptr);
+  RELEASE_ASSERT(marshaller_ptr != nullptr);
+  const auto& marshaller = *marshaller_ptr;
 
   const bool signature_contains_handles = marshaller.ContainsHandles();
 
@@ -4589,8 +4639,12 @@
 }
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfFfiCallback(const Function& function) {
-  const auto& marshaller =
-      *new (Z) compiler::ffi::CallbackMarshaller(Z, function);
+  const char* error = nullptr;
+  const auto marshaller_ptr =
+      compiler::ffi::CallbackMarshaller::FromFunction(Z, function, &error);
+  RELEASE_ASSERT(error == nullptr);
+  RELEASE_ASSERT(marshaller_ptr != nullptr);
+  const auto& marshaller = *marshaller_ptr;
 
   graph_entry_ =
       new (Z) GraphEntryInstr(*parsed_function_, Compiler::kNoOSRDeoptId);
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 2513eb4..df10c58 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -7553,12 +7553,26 @@
          kFfiHandleCid;
 }
 
+// Keep consistent with BaseMarshaller::IsCompound.
 bool Function::FfiCSignatureReturnsStruct() const {
   ASSERT(IsFfiTrampoline());
-  const FunctionType& c_signature = FunctionType::Handle(FfiCSignature());
-  const auto& return_type = AbstractType::Handle(c_signature.result_type());
-  const bool predefined = IsFfiTypeClassId(return_type.type_class_id());
-  return !predefined;
+  Zone* zone = Thread::Current()->zone();
+  const auto& c_signature = FunctionType::Handle(zone, FfiCSignature());
+  const auto& type = AbstractType::Handle(zone, c_signature.result_type());
+  if (IsFfiTypeClassId(type.type_class_id())) {
+    return false;
+  }
+  // TODO(http://dartbug.com/42563): Implement AbiSpecificInt.
+#ifdef DEBUG
+  const auto& cls = Class::Handle(zone, type.type_class());
+  const auto& superClass = Class::Handle(zone, cls.SuperClass());
+  const bool is_struct = String::Handle(zone, superClass.UserVisibleName())
+                             .Equals(Symbols::Struct());
+  const bool is_union = String::Handle(zone, superClass.UserVisibleName())
+                            .Equals(Symbols::Union());
+  RELEASE_ASSERT(is_struct || is_union);
+#endif
+  return true;
 }
 
 int32_t Function::FfiCallbackId() const {
diff --git a/sdk/lib/_internal/vm/lib/ffi_patch.dart b/sdk/lib/_internal/vm/lib/ffi_patch.dart
index 14180b6..3af29c3 100644
--- a/sdk/lib/_internal/vm/lib/ffi_patch.dart
+++ b/sdk/lib/_internal/vm/lib/ffi_patch.dart
@@ -448,6 +448,16 @@
         Pointer<Pointer<S>> pointer, int index) =>
     Pointer.fromAddress(pointer.address + _intPtrSize * index);
 
+@pragma("vm:prefer-inline")
+@pragma("vm:entry-point")
+T _checkAbiSpecificIntegerMapping<T>(T? object) {
+  if (object == null) {
+    throw ArgumentError(
+        'AbiSpecificInteger is missing mapping for "${Abi.current()}".');
+  }
+  return object;
+}
+
 extension NativeFunctionPointer<NF extends Function>
     on Pointer<NativeFunction<NF>> {
   @patch
diff --git a/tools/VERSION b/tools/VERSION
index 9dfdd80..e7063a5 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 16
 PATCH 0
-PRERELEASE 71
+PRERELEASE 72
 PRERELEASE_PATCH 0
\ No newline at end of file