diff --git a/pkg/analysis_server/test/analysis/update_content_test.dart b/pkg/analysis_server/test/analysis/update_content_test.dart
index d8894c8..f000bb7 100644
--- a/pkg/analysis_server/test/analysis/update_content_test.dart
+++ b/pkg/analysis_server/test/analysis/update_content_test.dart
@@ -8,7 +8,6 @@
 import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart' as plugin;
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
-import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
diff --git a/pkg/analysis_server/test/domain_completion_test.dart b/pkg/analysis_server/test/domain_completion_test.dart
index 59aaebb..e72baca 100644
--- a/pkg/analysis_server/test/domain_completion_test.dart
+++ b/pkg/analysis_server/test/domain_completion_test.dart
@@ -9,7 +9,6 @@
 import 'package:analysis_server/src/services/completion/dart/contribution_sorter.dart';
 import 'package:analyzer_plugin/protocol/protocol.dart' as plugin;
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
-import 'package:analyzer_plugin/protocol/protocol_constants.dart' as plugin;
 import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
diff --git a/pkg/analysis_server/test/edit/assists_test.dart b/pkg/analysis_server/test/edit/assists_test.dart
index 438a81e..3ab55f3 100644
--- a/pkg/analysis_server/test/edit/assists_test.dart
+++ b/pkg/analysis_server/test/edit/assists_test.dart
@@ -8,7 +8,6 @@
 import 'package:analyzer_plugin/protocol/protocol.dart' as plugin;
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
 import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
-import 'package:analyzer_plugin/src/protocol/protocol_internal.dart' as plugin;
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
diff --git a/pkg/analysis_server/test/edit/fixes_test.dart b/pkg/analysis_server/test/edit/fixes_test.dart
index 19588f5..660af49 100644
--- a/pkg/analysis_server/test/edit/fixes_test.dart
+++ b/pkg/analysis_server/test/edit/fixes_test.dart
@@ -8,7 +8,6 @@
 import 'package:analyzer_plugin/protocol/protocol.dart' as plugin;
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
 import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
-import 'package:analyzer_plugin/src/protocol/protocol_internal.dart' as plugin;
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
diff --git a/pkg/analysis_server/test/lsp/server_abstract.dart b/pkg/analysis_server/test/lsp/server_abstract.dart
index 64e8480..006ce0b 100644
--- a/pkg/analysis_server/test/lsp/server_abstract.dart
+++ b/pkg/analysis_server/test/lsp/server_abstract.dart
@@ -23,7 +23,6 @@
 import 'package:analyzer/src/test_utilities/package_config_file_builder.dart';
 import 'package:analyzer/src/test_utilities/resource_provider_mixin.dart';
 import 'package:analyzer_plugin/protocol/protocol.dart' as plugin;
-import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
 import 'package:analyzer_plugin/src/protocol/protocol_internal.dart' as plugin;
 import 'package:meta/meta.dart';
 import 'package:path/path.dart' as path;
diff --git a/pkg/analysis_server/test/plugin/protocol_dart_test.dart b/pkg/analysis_server/test/plugin/protocol_dart_test.dart
index 2fdf1c5..d693387 100644
--- a/pkg/analysis_server/test/plugin/protocol_dart_test.dart
+++ b/pkg/analysis_server/test/plugin/protocol_dart_test.dart
@@ -4,14 +4,8 @@
 
 import 'package:analysis_server/plugin/protocol/protocol_dart.dart';
 import 'package:analyzer/dart/ast/ast.dart' as engine;
-import 'package:analyzer/dart/ast/visitor.dart' as engine;
 import 'package:analyzer/dart/element/element.dart' as engine;
-import 'package:analyzer/dart/element/type.dart' as engine;
-import 'package:analyzer/error/error.dart' as engine;
-import 'package:analyzer/src/dart/ast/utilities.dart' as engine;
 import 'package:analyzer/src/dart/element/element.dart' as engine;
-import 'package:analyzer/src/error/codes.dart' as engine;
-import 'package:analyzer/src/generated/source.dart' as engine;
 import 'package:analyzer/src/generated/testing/element_search.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
 import 'package:test/test.dart';
diff --git a/pkg/analysis_server/test/protocol_server_test.dart b/pkg/analysis_server/test/protocol_server_test.dart
index 0ce5609..b355d68 100644
--- a/pkg/analysis_server/test/protocol_server_test.dart
+++ b/pkg/analysis_server/test/protocol_server_test.dart
@@ -9,9 +9,7 @@
 import 'package:analysis_server/src/services/search/search_engine.dart';
 import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer/dart/analysis/session.dart';
-import 'package:analyzer/dart/ast/ast.dart' as engine;
 import 'package:analyzer/dart/element/element.dart' as engine;
-import 'package:analyzer/dart/element/type.dart' as engine;
 import 'package:analyzer/diagnostic/diagnostic.dart';
 import 'package:analyzer/error/error.dart' as engine;
 import 'package:analyzer/src/dart/analysis/results.dart' as engine;
diff --git a/pkg/analysis_server/test/src/domain_abstract_test.dart b/pkg/analysis_server/test/src/domain_abstract_test.dart
index eb1fdb9..46c9aa6 100644
--- a/pkg/analysis_server/test/src/domain_abstract_test.dart
+++ b/pkg/analysis_server/test/src/domain_abstract_test.dart
@@ -6,7 +6,6 @@
 import 'package:analysis_server/src/plugin/plugin_manager.dart';
 import 'package:analysis_server/src/protocol_server.dart' hide Element;
 import 'package:analyzer_plugin/protocol/protocol.dart' as plugin;
-import 'package:analyzer_plugin/protocol/protocol_constants.dart' as plugin;
 import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
diff --git a/pkg/analysis_server/test/src/plugin/notification_manager_test.dart b/pkg/analysis_server/test/src/plugin/notification_manager_test.dart
index 88fd799..3157c0c 100644
--- a/pkg/analysis_server/test/src/plugin/notification_manager_test.dart
+++ b/pkg/analysis_server/test/src/plugin/notification_manager_test.dart
@@ -7,9 +7,7 @@
 import 'package:analysis_server/src/channel/channel.dart';
 import 'package:analysis_server/src/plugin/notification_manager.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
-import 'package:analyzer_plugin/protocol/protocol.dart' as plugin;
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
-import 'package:analyzer_plugin/protocol/protocol_constants.dart' as plugin;
 import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
diff --git a/pkg/analysis_server/test/src/plugin/request_converter_test.dart b/pkg/analysis_server/test/src/plugin/request_converter_test.dart
index 78d9858..7ba3049 100644
--- a/pkg/analysis_server/test/src/plugin/request_converter_test.dart
+++ b/pkg/analysis_server/test/src/plugin/request_converter_test.dart
@@ -4,7 +4,6 @@
 
 import 'package:analysis_server/protocol/protocol_generated.dart' as server;
 import 'package:analysis_server/src/plugin/request_converter.dart';
-import 'package:analysis_server/src/protocol/protocol_internal.dart' as server;
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
 import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
 import 'package:test/test.dart';
diff --git a/pkg/analysis_server/test/src/plugin/result_converter_test.dart b/pkg/analysis_server/test/src/plugin/result_converter_test.dart
index d45118b..220ca9a 100644
--- a/pkg/analysis_server/test/src/plugin/result_converter_test.dart
+++ b/pkg/analysis_server/test/src/plugin/result_converter_test.dart
@@ -4,7 +4,6 @@
 
 import 'package:analysis_server/protocol/protocol_generated.dart' as server;
 import 'package:analysis_server/src/plugin/result_converter.dart';
-import 'package:analysis_server/src/protocol/protocol_internal.dart' as server;
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
 import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
 import 'package:test/test.dart';
diff --git a/pkg/dartdev/lib/dartdev.dart b/pkg/dartdev/lib/dartdev.dart
index e2229b4..a97d843 100644
--- a/pkg/dartdev/lib/dartdev.dart
+++ b/pkg/dartdev/lib/dartdev.dart
@@ -156,8 +156,10 @@
   final Analytics analytics;
 
   @override
-  final ArgParser argParser =
-      ArgParser(usageLineLength: dartdevUsageLineLength);
+  final ArgParser argParser = ArgParser(
+    usageLineLength: dartdevUsageLineLength,
+    allowTrailingOptions: false,
+  );
 
   static const String dartdevDescription =
       'A command-line utility for Dart development';
diff --git a/pkg/dartdev/lib/src/commands/fix.dart b/pkg/dartdev/lib/src/commands/fix.dart
index 11dbee4..9f4d350 100644
--- a/pkg/dartdev/lib/src/commands/fix.dart
+++ b/pkg/dartdev/lib/src/commands/fix.dart
@@ -6,6 +6,7 @@
 import 'dart:io' as io;
 
 import 'package:analysis_server_client/protocol.dart' hide AnalysisError;
+import 'package:intl/intl.dart';
 import 'package:path/path.dart' as path;
 
 import '../analysis_server.dart';
@@ -26,8 +27,8 @@
 
   @override
   FutureOr<int> run() async {
-    log.stdout('\n*** The `fix` command is provisional and subject to change '
-        'or removal in future releases. ***\n');
+    log.stdout('\n${log.ansi.emphasized('Note:')} The `fix` command is '
+        'provisional and subject to change or removal in future releases.\n');
 
     var dryRun = argResults['dry-run'];
     if (argResults.rest.length - (dryRun ? 1 : 0) > 1) {
@@ -43,8 +44,9 @@
 
     var modeText = dryRun ? ' (dry run)' : '';
 
+    final projectName = path.basename(path.canonicalize(dir.path));
     var progress = log.progress(
-        'Computing fixes in ${path.basename(path.canonicalize(dir.path))}$modeText');
+        'Computing fixes in ${log.ansi.emphasized(projectName)}$modeText');
 
     var server = AnalysisServer(
       io.Directory(sdk.sdkPath),
@@ -88,22 +90,30 @@
           });
         });
 
-        log.stdout(
-            '\n$fixCount proposed ${_pluralFix(fixCount)} in $fileCount ${pluralize("file", fileCount)}.\n');
+        log.stdout('');
+
+        final bullet = log.ansi.bullet;
 
         for (var detail in details) {
           log.stdout(path.relative(detail.path, from: dir.path));
-          for (var fix in detail.fixes) {
-            log.stdout(
-                '  ${fix.code} • ${fix.occurrences} ${_pluralFix(fix.occurrences)}');
+          final fixes = detail.fixes.toList();
+          fixes.sort((a, b) => a.code.compareTo(b.code));
+          for (var fix in fixes) {
+            log.stdout('  ${fix.code} $bullet '
+                '${_format(fix.occurrences)} ${_pluralFix(fix.occurrences)}');
           }
+          log.stdout('');
         }
+
+        log.stdout('${_format(fixCount)} proposed ${_pluralFix(fixCount)} '
+            'in ${_format(fileCount)} ${pluralize("file", fileCount)}.');
       } else {
         progress = log.progress('Applying fixes');
         var fileCount = await _applyFixes(edits);
         progress.finish(showTiming: true);
         if (fileCount > 0) {
-          log.stdout('Fixed $fileCount ${pluralize("file", fileCount)}.');
+          log.stdout(
+              'Fixed ${_format(fileCount)} ${pluralize("file", fileCount)}.');
         }
       }
     }
@@ -125,4 +135,8 @@
   }
 
   String _pluralFix(int count) => count == 1 ? 'fix' : 'fixes';
+
+  static final NumberFormat _numberFormat = NumberFormat.decimalPattern();
+
+  static String _format(int value) => _numberFormat.format(value);
 }
diff --git a/pkg/dartdev/pubspec.yaml b/pkg/dartdev/pubspec.yaml
index aea30a3..d6347db 100644
--- a/pkg/dartdev/pubspec.yaml
+++ b/pkg/dartdev/pubspec.yaml
@@ -15,6 +15,7 @@
   dart2native:
     path: ../dart2native
   dart_style: any
+  intl: any
   meta:
     path: ../meta
   nnbd_migration:
diff --git a/pkg/dartdev/test/commands/fix_test.dart b/pkg/dartdev/test/commands/fix_test.dart
index 101edbf..ff885d6 100644
--- a/pkg/dartdev/test/commands/fix_test.dart
+++ b/pkg/dartdev/test/commands/fix_test.dart
@@ -4,6 +4,7 @@
 
 import 'dart:io';
 
+import 'package:cli_util/cli_logging.dart';
 import 'package:test/test.dart';
 
 import '../utils.dart';
@@ -15,6 +16,8 @@
 void defineFix() {
   TestProject p;
 
+  final bullet = Logger.standard().ansi.bullet;
+
   setUp(() => p = null);
 
   tearDown(() => p?.dispose());
@@ -67,8 +70,8 @@
     expect(result.stderr, isEmpty);
     expect(result.stdout, contains('3 proposed fixes in 1 file.'));
     expect(result.stdout, contains('lib${Platform.pathSeparator}main.dart'));
-    expect(result.stdout, contains('  annotate_overrides • 1 fix'));
-    expect(result.stdout, contains('  prefer_single_quotes • 2 fixes'));
+    expect(result.stdout, contains('  annotate_overrides $bullet 1 fix'));
+    expect(result.stdout, contains('  prefer_single_quotes $bullet 2 fixes'));
   });
 
   test('.', () {
diff --git a/pkg/dartdev/test/no_such_file_test.dart b/pkg/dartdev/test/no_such_file_test.dart
new file mode 100644
index 0000000..1641dfc
--- /dev/null
+++ b/pkg/dartdev/test/no_such_file_test.dart
@@ -0,0 +1,39 @@
+// Copyright (c) 2020, 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:test/test.dart';
+
+import 'utils.dart';
+
+void main() {
+  TestProject p;
+
+  tearDown(() => p?.dispose());
+
+  test('Ensure parsing fails after encountering invalid file', () {
+    // Regression test for https://github.com/dart-lang/sdk/issues/43991
+    p = project();
+    final noArgsResult = p.runSync('foo.dart', []);
+    expect(noArgsResult.stderr, isNotEmpty);
+    expect(noArgsResult.stdout, isEmpty);
+    expect(noArgsResult.exitCode, 64);
+
+    final argsResult = p.runSync('foo.dart', ['--bar']);
+    expect(argsResult.stderr, noArgsResult.stderr);
+    expect(argsResult.stdout, isEmpty);
+    expect(argsResult.exitCode, 64);
+  });
+
+  test('Providing --snapshot VM option with invalid script fails gracefully',
+      () {
+    // Regression test for https://github.com/dart-lang/sdk/issues/43785
+    p = project();
+    final result = p.runSync('--snapshot=abc', ['foo.dart']);
+    expect(result.stderr, isNotEmpty);
+    expect(result.stderr,
+        contains("Error when reading 'foo.dart': No such file or directory"));
+    expect(result.stdout, isEmpty);
+    expect(result.exitCode, 254);
+  });
+}
diff --git a/pkg/dartdev/test/test_all.dart b/pkg/dartdev/test/test_all.dart
index 291bd05..2576ac9 100644
--- a/pkg/dartdev/test/test_all.dart
+++ b/pkg/dartdev/test/test_all.dart
@@ -18,6 +18,7 @@
 import 'commands/test_test.dart' as test;
 import 'core_test.dart' as core;
 import 'experiments_test.dart' as experiments;
+import 'no_such_file_test.dart' as no_such_file;
 import 'sdk_test.dart' as sdk;
 import 'smoke/implicit_smoke_test.dart' as implicit_smoke;
 import 'smoke/invalid_smoke_test.dart' as invalid_smoke;
@@ -37,6 +38,7 @@
     implicit_smoke.main();
     invalid_smoke.main();
     migrate.main();
+    no_such_file.main();
     pub.main();
     run.main();
     compile.main();
diff --git a/pkg/dev_compiler/lib/src/kernel/expression_compiler.dart b/pkg/dev_compiler/lib/src/kernel/expression_compiler.dart
index 92cca7c..eb746a7 100644
--- a/pkg/dev_compiler/lib/src/kernel/expression_compiler.dart
+++ b/pkg/dev_compiler/lib/src/kernel/expression_compiler.dart
@@ -12,7 +12,6 @@
 import 'package:_fe_analyzer_shared/src/messages/codes.dart' show Message, Code;
 
 import 'package:dev_compiler/dev_compiler.dart';
-import 'package:dev_compiler/src/compiler/js_names.dart' as js_ast;
 import 'package:dev_compiler/src/js_ast/js_ast.dart' as js_ast;
 import 'package:dev_compiler/src/kernel/compiler.dart';
 
diff --git a/pkg/dev_compiler/lib/src/kernel/target.dart b/pkg/dev_compiler/lib/src/kernel/target.dart
index eb2f225..d22ded9 100644
--- a/pkg/dev_compiler/lib/src/kernel/target.dart
+++ b/pkg/dev_compiler/lib/src/kernel/target.dart
@@ -151,8 +151,7 @@
       ChangedStructureNotifier changedStructureNotifier}) {
     for (var library in libraries) {
       _CovarianceTransformer(library).transform();
-      JsInteropChecks(
-              coreTypes,
+      JsInteropChecks(coreTypes,
               diagnosticReporter as DiagnosticReporter<Message, LocatedMessage>)
           .visitLibrary(library);
     }
diff --git a/runtime/bin/ffi_test/ffi_test_functions.cc b/runtime/bin/ffi_test/ffi_test_functions.cc
index 3304154..57d6a01 100644
--- a/runtime/bin/ffi_test/ffi_test_functions.cc
+++ b/runtime/bin/ffi_test/ffi_test_functions.cc
@@ -610,8 +610,8 @@
 }
 
 // A struct designed to exercise all kinds of alignment rules.
-// Note that offset32A (System V ia32) aligns doubles on 4 bytes while offset32B
-// (Arm 32 bit and MSVC ia32) aligns on 8 bytes.
+// Note that offset32A (System V ia32, iOS arm) aligns doubles on 4 bytes while
+// offset32B (Arm 32 bit and MSVC ia32) aligns on 8 bytes.
 // TODO(37271): Support nested structs.
 // TODO(37470): Add uncommon primitive data types when we want to support them.
 struct VeryLargeStruct {
diff --git a/runtime/bin/main_options.cc b/runtime/bin/main_options.cc
index 452346f..2e962c1 100644
--- a/runtime/bin/main_options.cc
+++ b/runtime/bin/main_options.cc
@@ -478,6 +478,7 @@
     bool is_potential_file_path = true;
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
     if (Options::disable_dart_dev() ||
+        (Options::snapshot_filename() != nullptr) ||
         (is_potential_file_path && !enable_vm_service_)) {
       *script_name = Utils::StrDup(argv[i]);
       run_script = true;
diff --git a/runtime/vm/compiler/compiler_sources.gni b/runtime/vm/compiler/compiler_sources.gni
index c4572df..ad10b9c 100644
--- a/runtime/vm/compiler/compiler_sources.gni
+++ b/runtime/vm/compiler/compiler_sources.gni
@@ -179,6 +179,7 @@
   "backend/typed_data_aot_test.cc",
   "backend/yield_position_test.cc",
   "cha_test.cc",
+  "ffi/native_type_vm_test.cc",
   "frontend/kernel_binary_flowgraph_test.cc",
   "frontend/multiple_entrypoints_test.cc",
   "write_barrier_elimination_test.cc",
diff --git a/runtime/vm/compiler/ffi/native_location.h b/runtime/vm/compiler/ffi/native_location.h
index 3437e5c..614798a 100644
--- a/runtime/vm/compiler/ffi/native_location.h
+++ b/runtime/vm/compiler/ffi/native_location.h
@@ -11,6 +11,7 @@
 
 #include "platform/assert.h"
 #include "vm/compiler/ffi/native_type.h"
+#include "vm/compiler/runtime_api.h"
 #include "vm/constants.h"
 #include "vm/growable_array.h"
 
@@ -24,10 +25,6 @@
 
 namespace compiler {
 
-namespace target {
-extern const int kWordSize;
-}
-
 namespace ffi {
 
 class NativeRegistersLocation;
diff --git a/runtime/vm/compiler/ffi/native_type.cc b/runtime/vm/compiler/ffi/native_type.cc
index db06400..20c33dd 100644
--- a/runtime/vm/compiler/ffi/native_type.cc
+++ b/runtime/vm/compiler/ffi/native_type.cc
@@ -14,6 +14,10 @@
 #include "vm/compiler/backend/locations.h"
 #endif  // !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
 
+#if !defined(FFI_UNIT_TESTS)
+#include "vm/symbols.h"
+#endif
+
 namespace dart {
 
 namespace compiler {
@@ -25,6 +29,11 @@
   return static_cast<const NativePrimitiveType&>(*this);
 }
 
+const NativeCompoundType& NativeType::AsCompound() const {
+  ASSERT(IsCompound());
+  return static_cast<const NativeCompoundType&>(*this);
+}
+
 bool NativePrimitiveType::IsInt() const {
   switch (representation_) {
     case kInt8:
@@ -127,6 +136,57 @@
   }
 }
 
+static bool ContainsHomogenuousFloatsInternal(const NativeTypes& types);
+
+// Keep consistent with
+// pkg/vm/lib/transformations/ffi_definitions.dart:_calculateSizeAndOffsets.
+NativeCompoundType& NativeCompoundType::FromNativeTypes(
+    Zone* zone,
+    const NativeTypes& members) {
+  intptr_t offset = 0;
+
+  const intptr_t kAtLeast1ByteAligned = 1;
+  // If this struct is nested in another struct, it should be aligned to the
+  // largest alignment of its members.
+  intptr_t alignment_field = kAtLeast1ByteAligned;
+  // If this struct is passed on the stack, it should be aligned to the largest
+  // alignment of its members when passing those members on the stack.
+  intptr_t alignment_stack = kAtLeast1ByteAligned;
+#if defined(TARGET_OS_MACOS_IOS) && defined(TARGET_ARCH_ARM64)
+  // On iOS64 stack values can be less aligned than wordSize, which deviates
+  // from the arm64 ABI.
+  ASSERT(CallingConventions::kArgumentStackAlignment == kAlignedToValueSize);
+  // Because the arm64 ABI aligns primitives to word size on the stack, every
+  // struct will be automatically aligned to word size. iOS64 does not align
+  // the primitives to word size, so we set structs to align to word size for
+  // iOS64.
+  // However, homogenous structs are treated differently. They are aligned to
+  // their member alignment. (Which is 4 in case of a homogenous float).
+  // Source: manual testing.
+  if (!ContainsHomogenuousFloatsInternal(members)) {
+    alignment_stack = compiler::target::kWordSize;
+  }
+#endif
+
+  auto& member_offsets =
+      *new (zone) ZoneGrowableArray<intptr_t>(zone, members.length());
+  for (intptr_t i = 0; i < members.length(); i++) {
+    const NativeType& member = *members[i];
+    const intptr_t member_size = member.SizeInBytes();
+    const intptr_t member_align_field = member.AlignmentInBytesField();
+    const intptr_t member_align_stack = member.AlignmentInBytesStack();
+    offset = Utils::RoundUp(offset, member_align_field);
+    member_offsets.Add(offset);
+    offset += member_size;
+    alignment_field = Utils::Maximum(alignment_field, member_align_field);
+    alignment_stack = Utils::Maximum(alignment_stack, member_align_stack);
+  }
+  const intptr_t size = Utils::RoundUp(offset, alignment_field);
+
+  return *new (zone) NativeCompoundType(members, member_offsets, size,
+                                        alignment_field, alignment_stack);
+}
+
 #if !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
 bool NativePrimitiveType::IsExpressibleAsRepresentation() const {
   switch (representation_) {
@@ -139,7 +199,7 @@
     case kInt32:
     case kUint32:
     case kInt64:
-    case kUint64:
+    case kUint64:  // We don't actually have a kUnboxedUint64.
     case kFloat:
     case kDouble:
       return true;
@@ -179,6 +239,23 @@
   return other.AsPrimitive().representation_ == representation_;
 }
 
+bool NativeCompoundType::Equals(const NativeType& other) const {
+  if (!other.IsCompound()) {
+    return false;
+  }
+  const auto& other_compound = other.AsCompound();
+  const auto& other_members = other_compound.members_;
+  if (other_members.length() != members_.length()) {
+    return false;
+  }
+  for (intptr_t i = 0; i < members_.length(); i++) {
+    if (!members_[i]->Equals(*other_members[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
 static PrimitiveType split_fundamental(PrimitiveType in) {
   switch (in) {
     case kInt16:
@@ -243,16 +320,52 @@
   }
 }
 
+static bool IsPredefinedFfiCid(classid_t class_id) {
+  switch (class_id) {
+#define CASE_FFI_CID_TRUE(name)                                                \
+  case kFfi##name##Cid:                                                        \
+    return true;
+    CLASS_LIST_FFI(CASE_FFI_CID_TRUE)
+    default:
+      return false;
+  }
+  UNREACHABLE();
+}
+
 NativeType& NativeType::FromTypedDataClassId(Zone* zone, classid_t class_id) {
-  // TODO(36730): Support composites.
+  ASSERT(IsPredefinedFfiCid(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) {
-  // TODO(36730): Support composites.
-  return NativeType::FromTypedDataClassId(zone, type.type_class_id());
+  const classid_t class_id = type.type_class_id();
+  if (IsPredefinedFfiCid(class_id)) {
+    return NativeType::FromTypedDataClassId(zone, class_id);
+  }
+
+  // User-defined structs.
+  const auto& cls = Class::Handle(zone, type.type_class());
+
+  auto& options = Object::Handle(zone);
+  Library::FindPragma(dart::Thread::Current(), /*only_core=*/false, cls,
+                      Symbols::vm_ffi_struct_fields(), &options);
+  ASSERT(!options.IsNull());
+  ASSERT(options.IsArray());
+
+  const auto& field_types = Array::Cast(options);
+  auto& field_type = AbstractType::Handle(zone);
+  auto& field_native_types = *new (zone) ZoneGrowableArray<const NativeType*>(
+      zone, field_types.Length());
+  for (intptr_t i = 0; i < field_types.Length(); i++) {
+    field_type ^= field_types.At(i);
+    const NativeType& field_native_type =
+        NativeType::FromAbstractType(zone, field_type);
+    field_native_types.Add(&field_native_type);
+  }
+
+  return NativeCompoundType::FromNativeTypes(zone, field_native_types);
 }
 #endif
 
@@ -281,15 +394,15 @@
 }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
 
-const char* NativeType::ToCString(Zone* zone) const {
+const char* NativeType::ToCString(Zone* zone, bool multi_line) const {
   ZoneTextBuffer textBuffer(zone);
-  PrintTo(&textBuffer);
+  PrintTo(&textBuffer, multi_line);
   return textBuffer.buffer();
 }
 
 #if !defined(FFI_UNIT_TESTS)
-const char* NativeType::ToCString() const {
-  return ToCString(Thread::Current()->zone());
+const char* NativeType::ToCString(bool multi_line) const {
+  return ToCString(Thread::Current()->zone(), multi_line);
 }
 #endif
 
@@ -324,11 +437,11 @@
   }
 }
 
-void NativeType::PrintTo(BaseTextBuffer* f) const {
+void NativeType::PrintTo(BaseTextBuffer* f, bool multi_line) const {
   f->AddString("I");
 }
 
-void NativePrimitiveType::PrintTo(BaseTextBuffer* f) const {
+void NativePrimitiveType::PrintTo(BaseTextBuffer* f, bool multi_line) const {
   f->Printf("%s", PrimitiveTypeToCString(representation_));
 }
 
@@ -338,6 +451,35 @@
   return textBuffer.buffer();
 }
 
+void NativeCompoundType::PrintTo(BaseTextBuffer* f, bool multi_line) const {
+  f->AddString("Compound(");
+  f->Printf("size: %" Pd ", ", SizeInBytes());
+  f->Printf("field alignment: %" Pd ", ", AlignmentInBytesField());
+  f->Printf("stack alignment: %" Pd ", ", AlignmentInBytesStack());
+  f->AddString("members: {");
+  if (multi_line) {
+    f->AddString("\n  ");
+  }
+  for (intptr_t i = 0; i < members_.length(); i++) {
+    if (i > 0) {
+      if (multi_line) {
+        f->AddString(",\n  ");
+      } else {
+        f->AddString(", ");
+      }
+    }
+    f->Printf("%" Pd ": ", member_offsets_[i]);
+    members_[i]->PrintTo(f);
+  }
+  if (multi_line) {
+    f->AddString("\n");
+  }
+  f->AddString("})");
+  if (multi_line) {
+    f->AddString("\n");
+  }
+}
+
 #if !defined(FFI_UNIT_TESTS)
 const char* NativeFunctionType::ToCString() const {
   return ToCString(Thread::Current()->zone());
@@ -356,6 +498,88 @@
   return_type_.PrintTo(f);
 }
 
+bool NativeCompoundType::ContainsOnlyFloats(intptr_t offset_in_bytes,
+                                            intptr_t size_in_bytes) const {
+  ASSERT(size_in_bytes >= 0);
+  const intptr_t first_byte = offset_in_bytes;
+  const intptr_t last_byte = offset_in_bytes + size_in_bytes - 1;
+  for (intptr_t i = 0; i < members_.length(); i++) {
+    const intptr_t member_first_byte = member_offsets_[i];
+    const intptr_t member_last_byte =
+        member_first_byte + members_[i]->SizeInBytes() - 1;
+    if ((first_byte <= member_first_byte && member_first_byte <= last_byte) ||
+        (first_byte <= member_last_byte && member_last_byte <= last_byte)) {
+      if (members_[i]->IsPrimitive() && !members_[i]->IsFloat()) {
+        return false;
+      }
+      if (members_[i]->IsCompound()) {
+        const auto& nested = members_[i]->AsCompound();
+        const bool nested_only_floats = nested.ContainsOnlyFloats(
+            offset_in_bytes - member_first_byte, size_in_bytes);
+        if (!nested_only_floats) {
+          return false;
+        }
+      }
+    }
+    if (member_first_byte > last_byte) {
+      // None of the remaining members fits the range.
+      break;
+    }
+  }
+  return true;
+}
+
+intptr_t NativeCompoundType::NumberOfWordSizeChunksOnlyFloat() const {
+  // O(n^2) implementation, but only invoked for small structs.
+  ASSERT(SizeInBytes() <= 16);
+  const intptr_t size = SizeInBytes();
+  intptr_t float_only_chunks = 0;
+  for (intptr_t offset = 0; offset < size;
+       offset += compiler::target::kWordSize) {
+    if (ContainsOnlyFloats(
+            offset, Utils::Minimum<intptr_t>(size - offset,
+                                             compiler::target::kWordSize))) {
+      float_only_chunks++;
+    }
+  }
+  return float_only_chunks;
+}
+
+intptr_t NativeCompoundType::NumberOfWordSizeChunksNotOnlyFloat() const {
+  const intptr_t total_chunks =
+      Utils::RoundUp(SizeInBytes(), compiler::target::kWordSize) /
+      compiler::target::kWordSize;
+  return total_chunks - NumberOfWordSizeChunksOnlyFloat();
+}
+
+static void ContainsHomogenuousFloatsRecursive(const NativeTypes& types,
+                                               bool* only_float,
+                                               bool* only_double) {
+  for (intptr_t i = 0; i < types.length(); i++) {
+    const auto& member_type = types.At(i);
+    if (member_type->IsPrimitive()) {
+      PrimitiveType type = member_type->AsPrimitive().representation();
+      *only_float = *only_float && (type == kFloat);
+      *only_double = *only_double && (type == kDouble);
+    }
+    if (member_type->IsCompound()) {
+      ContainsHomogenuousFloatsRecursive(member_type->AsCompound().members(),
+                                         only_float, only_double);
+    }
+  }
+}
+
+static bool ContainsHomogenuousFloatsInternal(const NativeTypes& types) {
+  bool only_float = true;
+  bool only_double = true;
+  ContainsHomogenuousFloatsRecursive(types, &only_float, &only_double);
+  return (only_double || only_float) && types.length() > 0;
+}
+
+bool NativeCompoundType::ContainsHomogenuousFloats() const {
+  return ContainsHomogenuousFloatsInternal(this->members());
+}
+
 const NativeType& NativeType::WidenTo4Bytes(Zone* zone) const {
   if (IsInt() && SizeInBytes() <= 2) {
     if (IsSigned()) {
diff --git a/runtime/vm/compiler/ffi/native_type.h b/runtime/vm/compiler/ffi/native_type.h
index 3c11341..eaf4129 100644
--- a/runtime/vm/compiler/ffi/native_type.h
+++ b/runtime/vm/compiler/ffi/native_type.h
@@ -26,6 +26,7 @@
 namespace ffi {
 
 class NativePrimitiveType;
+class NativeCompoundType;
 
 // NativeTypes are the types used in calling convention specifications:
 // integers, floats, and composites.
@@ -40,17 +41,15 @@
 //
 // Instead, NativeTypes support representations not supported in Dart's unboxed
 // Representations, such as:
-// * Primitive types:
+// * Primitive types (https://en.cppreference.com/w/cpp/language/types):
 //   * int8_t
 //   * int16_t
 //   * uint8_t
 //   * uint16t
 //   * void
-// * Compound types:
+// * Compound types (https://en.cppreference.com/w/cpp/language/type):
 //   * Struct
 //   * Union
-//
-// TODO(36730): Add composites.
 class NativeType : public ZoneAllocated {
  public:
 #if !defined(FFI_UNIT_TESTS)
@@ -65,6 +64,8 @@
 
   virtual bool IsPrimitive() const { return false; }
   const NativePrimitiveType& AsPrimitive() const;
+  virtual bool IsCompound() const { return false; }
+  const NativeCompoundType& AsCompound() const;
 
   virtual bool IsInt() const { return false; }
   virtual bool IsFloat() const { return false; }
@@ -106,10 +107,10 @@
   // Otherwise, return original representation.
   const NativeType& WidenTo4Bytes(Zone* zone) const;
 
-  virtual void PrintTo(BaseTextBuffer* f) const;
-  const char* ToCString(Zone* zone) const;
+  virtual void PrintTo(BaseTextBuffer* f, bool multi_line = false) const;
+  const char* ToCString(Zone* zone, bool multi_line = false) const;
 #if !defined(FFI_UNIT_TESTS)
-  const char* ToCString() const;
+  const char* ToCString(bool multi_line = false) const;
 #endif
 
   virtual ~NativeType() {}
@@ -166,7 +167,7 @@
   virtual bool Equals(const NativeType& other) const;
   virtual NativePrimitiveType& Split(Zone* zone, intptr_t part) const;
 
-  virtual void PrintTo(BaseTextBuffer* f) const;
+  virtual void PrintTo(BaseTextBuffer* f, bool multi_line = false) const;
 
   virtual ~NativePrimitiveType() {}
 
@@ -176,6 +177,72 @@
 
 using NativeTypes = ZoneGrowableArray<const NativeType*>;
 
+// Struct
+//
+// TODO(dartbug.com/38491): Support unions.
+// TODO(dartbug.com/37271): Support nested compound types.
+// TODO(dartbug.com/35763): Support inline fixed-length arrays.
+class NativeCompoundType : public NativeType {
+ public:
+  static NativeCompoundType& FromNativeTypes(Zone* zone,
+                                             const NativeTypes& members);
+
+  const NativeTypes& members() const { return members_; }
+  const ZoneGrowableArray<intptr_t>& member_offsets() const {
+    return member_offsets_;
+  }
+
+  virtual bool IsCompound() const { return true; }
+
+  virtual intptr_t SizeInBytes() const { return size_; }
+  virtual intptr_t AlignmentInBytesField() const { return alignment_field_; }
+  virtual intptr_t AlignmentInBytesStack() const { return alignment_stack_; }
+
+  virtual bool Equals(const NativeType& other) const;
+
+  virtual void PrintTo(BaseTextBuffer* f, bool multi_line = false) const;
+
+  // Whether a range within a struct contains only floats.
+  //
+  // Useful for determining whether struct is passed in FP registers on x64.
+  bool ContainsOnlyFloats(intptr_t offset_in_bytes,
+                          intptr_t size_in_bytes) const;
+
+  // Returns how many word-sized chuncks _only_ contain floats.
+  //
+  // Useful for determining whether struct is passed in FP registers on x64.
+  intptr_t NumberOfWordSizeChunksOnlyFloat() const;
+
+  // Returns how many word-sized chunks do not _only_ contain floats.
+  //
+  // Useful for determining whether struct is passed in FP registers on x64.
+  intptr_t NumberOfWordSizeChunksNotOnlyFloat() const;
+
+  // Whether this type has only same-size floating point members.
+  //
+  // Useful for determining whether struct is passed in FP registers in hardfp
+  // and arm64.
+  bool ContainsHomogenuousFloats() const;
+
+ private:
+  NativeCompoundType(const NativeTypes& members,
+                     const ZoneGrowableArray<intptr_t>& member_offsets,
+                     intptr_t size,
+                     intptr_t alignment_field,
+                     intptr_t alignment_stack)
+      : members_(members),
+        member_offsets_(member_offsets),
+        size_(size),
+        alignment_field_(alignment_field),
+        alignment_stack_(alignment_stack) {}
+
+  const NativeTypes& members_;
+  const ZoneGrowableArray<intptr_t>& member_offsets_;
+  const intptr_t size_;
+  const intptr_t alignment_field_;
+  const intptr_t alignment_stack_;
+};
+
 class NativeFunctionType : public ZoneAllocated {
  public:
   NativeFunctionType(const NativeTypes& argument_types,
diff --git a/runtime/vm/compiler/ffi/native_type_test.cc b/runtime/vm/compiler/ffi/native_type_test.cc
index abf275d..66fa987 100644
--- a/runtime/vm/compiler/ffi/native_type_test.cc
+++ b/runtime/vm/compiler/ffi/native_type_test.cc
@@ -4,12 +4,44 @@
 
 #include "vm/compiler/ffi/unit_test.h"
 
+#include "platform/syslog.h"
 #include "vm/compiler/ffi/native_type.h"
+#include "vm/compiler/runtime_api.h"
 
 namespace dart {
 namespace compiler {
 namespace ffi {
 
+const NativeCompoundType& RunStructTest(dart::Zone* zone,
+                                        const char* name,
+                                        const NativeTypes& member_types) {
+  const auto& struct_type =
+      NativeCompoundType::FromNativeTypes(zone, member_types);
+
+  const char* test_result = struct_type.ToCString(zone, /*multi_line=*/true);
+
+  const int kFilePathLength = 100;
+  char expectation_file_path[kFilePathLength];
+  Utils::SNPrint(expectation_file_path, kFilePathLength,
+                 "runtime/vm/compiler/ffi/unit_tests/%s/%s_%s.expect", name,
+                 kArch, kOs);
+
+  if (TestCaseBase::update_expectations) {
+    Syslog::Print("Updating %s\n", expectation_file_path);
+    WriteToFile(expectation_file_path, test_result);
+  }
+
+  char* expectation_file_contents = nullptr;
+  ReadFromFile(expectation_file_path, &expectation_file_contents);
+  EXPECT_NOTNULL(expectation_file_contents);
+  if (expectation_file_contents != nullptr) {
+    EXPECT_STREQ(expectation_file_contents, test_result);
+    free(expectation_file_contents);
+  }
+
+  return struct_type;
+}
+
 UNIT_TEST_CASE_WITH_ZONE(NativeType) {
   const auto& native_type = *new (Z) NativePrimitiveType(kInt8);
 
@@ -20,6 +52,107 @@
   EXPECT_STREQ("int8", native_type.ToCString(Z));
 }
 
+UNIT_TEST_CASE_WITH_ZONE(NativeCompoundType_int8x10) {
+  const auto& int8type = *new (Z) NativePrimitiveType(kInt8);
+
+  auto& members = *new (Z) NativeTypes(Z, 10);
+  members.Add(&int8type);
+  members.Add(&int8type);
+  members.Add(&int8type);
+  members.Add(&int8type);
+  members.Add(&int8type);
+  members.Add(&int8type);
+  members.Add(&int8type);
+  members.Add(&int8type);
+  members.Add(&int8type);
+  members.Add(&int8type);
+
+  const auto& struct_type = RunStructTest(Z, "struct_int8x10", members);
+
+  EXPECT(!struct_type.ContainsHomogenuousFloats());
+  EXPECT(!struct_type.ContainsOnlyFloats(0, 8));
+  EXPECT_EQ(0, struct_type.NumberOfWordSizeChunksOnlyFloat());
+  EXPECT_EQ(
+      Utils::RoundUp(struct_type.SizeInBytes(), compiler::target::kWordSize) /
+          compiler::target::kWordSize,
+      struct_type.NumberOfWordSizeChunksNotOnlyFloat());
+}
+
+UNIT_TEST_CASE_WITH_ZONE(NativeCompoundType_floatx4) {
+  const auto& float_type = *new (Z) NativePrimitiveType(kFloat);
+
+  auto& members = *new (Z) NativeTypes(Z, 4);
+  members.Add(&float_type);
+  members.Add(&float_type);
+  members.Add(&float_type);
+  members.Add(&float_type);
+
+  const auto& struct_type = RunStructTest(Z, "struct_floatx4", members);
+
+  // This is a homogenous float in the arm and arm64 ABIs.
+  //
+  // On Arm64 iOS stack alignment of homogenous floats is not word size see
+  // runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm64_ios.expect.
+  EXPECT(struct_type.ContainsHomogenuousFloats());
+
+  // On x64, 8-byte parts of the chunks contain only floats and will be passed
+  // in FPU registers.
+  EXPECT(struct_type.ContainsOnlyFloats(0, 8));
+  EXPECT(struct_type.ContainsOnlyFloats(8, 8));
+  EXPECT_EQ(struct_type.SizeInBytes() / compiler::target::kWordSize,
+            struct_type.NumberOfWordSizeChunksOnlyFloat());
+  EXPECT_EQ(0, struct_type.NumberOfWordSizeChunksNotOnlyFloat());
+}
+
+// A struct designed to exercise all kinds of alignment rules.
+// Note that offset32A (System V ia32, iOS arm) aligns doubles on 4 bytes while
+// offset32B (Arm 32 bit and MSVC ia32) aligns on 8 bytes.
+// TODO(37271): Support nested structs.
+// TODO(37470): Add uncommon primitive data types when we want to support them.
+struct VeryLargeStruct {
+  //                             size32 size64 offset32A offset32B offset64
+  int8_t a;                   // 1              0         0         0
+  int16_t b;                  // 2              2         2         2
+  int32_t c;                  // 4              4         4         4
+  int64_t d;                  // 8              8         8         8
+  uint8_t e;                  // 1             16        16        16
+  uint16_t f;                 // 2             18        18        18
+  uint32_t g;                 // 4             20        20        20
+  uint64_t h;                 // 8             24        24        24
+  intptr_t i;                 // 4      8      32        32        32
+  double j;                   // 8             36        40        40
+  float k;                    // 4             44        48        48
+  VeryLargeStruct* parent;    // 4      8      48        52        56
+  intptr_t numChildren;       // 4      8      52        56        64
+  VeryLargeStruct* children;  // 4      8      56        60        72
+  int8_t smallLastField;      // 1             60        64        80
+                              // sizeof        64        72        88
+};
+
+UNIT_TEST_CASE_WITH_ZONE(NativeCompoundType_VeryLargeStruct) {
+  const auto& intptr_type = *new (Z) NativePrimitiveType(
+      compiler::target::kWordSize == 4 ? kInt32 : kInt64);
+
+  auto& members = *new (Z) NativeTypes(Z, 15);
+  members.Add(new (Z) NativePrimitiveType(kInt8));
+  members.Add(new (Z) NativePrimitiveType(kInt16));
+  members.Add(new (Z) NativePrimitiveType(kInt32));
+  members.Add(new (Z) NativePrimitiveType(kInt64));
+  members.Add(new (Z) NativePrimitiveType(kUint8));
+  members.Add(new (Z) NativePrimitiveType(kUint16));
+  members.Add(new (Z) NativePrimitiveType(kUint32));
+  members.Add(new (Z) NativePrimitiveType(kUint64));
+  members.Add(&intptr_type);
+  members.Add(new (Z) NativePrimitiveType(kDouble));
+  members.Add(new (Z) NativePrimitiveType(kFloat));
+  members.Add(&intptr_type);
+  members.Add(&intptr_type);
+  members.Add(&intptr_type);
+  members.Add(new (Z) NativePrimitiveType(kInt8));
+
+  RunStructTest(Z, "struct_VeryLargeStruct", members);
+}
+
 }  // namespace ffi
 }  // namespace compiler
 }  // namespace dart
diff --git a/runtime/vm/compiler/ffi/native_type_vm_test.cc b/runtime/vm/compiler/ffi/native_type_vm_test.cc
new file mode 100644
index 0000000..52f0835
--- /dev/null
+++ b/runtime/vm/compiler/ffi/native_type_vm_test.cc
@@ -0,0 +1,62 @@
+// Copyright (c) 2020, 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.
+
+#include "vm/compiler/ffi/native_type.h"
+
+#include "vm/compiler/backend/il_test_helper.h"
+#include "vm/unit_test.h"
+
+namespace dart {
+namespace compiler {
+namespace ffi {
+
+ISOLATE_UNIT_TEST_CASE(Ffi_NativeType_Primitive_FromAbstractType) {
+  Zone* Z = thread->zone();
+
+  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);
+
+  EXPECT_EQ(1, native_type.SizeInBytes());
+  EXPECT_STREQ("int8", native_type.ToCString());
+  EXPECT(native_type.IsInt());
+  EXPECT(native_type.IsPrimitive());
+}
+
+// Test that we construct `NativeType` correctly from `Type`.
+ISOLATE_UNIT_TEST_CASE(Ffi_NativeType_Struct_FromAbstractType) {
+  Zone* Z = thread->zone();
+
+  const char* kScript =
+      R"(
+      import 'dart:ffi';
+
+      class MyStruct extends Struct {
+        @Int8()
+        external int a0;
+
+        external Pointer<Int8> a1;
+      }
+      )";
+
+  const auto& root_library = Library::Handle(LoadTestScript(kScript));
+  const auto& struct_class = Class::Handle(GetClass(root_library, "MyStruct"));
+  const auto& struct_type = Type::Handle(struct_class.DeclarationType());
+
+  const auto& native_type =
+      NativeType::FromAbstractType(Z, struct_type).AsCompound();
+
+  EXPECT_EQ(2, native_type.members().length());
+
+  const auto& int8_type = *new (Z) NativePrimitiveType(kInt8);
+  EXPECT(int8_type.Equals(*native_type.members()[0]));
+
+  EXPECT_EQ(compiler::target::kWordSize,
+            native_type.members()[1]->SizeInBytes());
+}
+
+}  // namespace ffi
+}  // namespace compiler
+}  // namespace dart
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm64_android.expect
new file mode 100644
index 0000000..ca69b6c
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm64_android.expect
@@ -0,0 +1,17 @@
+Compound(size: 88, field alignment: 8, stack alignment: 8, members: {
+  0: int8,
+  2: int16,
+  4: int32,
+  8: int64,
+  16: uint8,
+  18: uint16,
+  20: uint32,
+  24: uint64,
+  32: int64,
+  40: double,
+  48: float,
+  56: int64,
+  64: int64,
+  72: int64,
+  80: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm64_ios.expect
new file mode 100644
index 0000000..ca69b6c
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm64_ios.expect
@@ -0,0 +1,17 @@
+Compound(size: 88, field alignment: 8, stack alignment: 8, members: {
+  0: int8,
+  2: int16,
+  4: int32,
+  8: int64,
+  16: uint8,
+  18: uint16,
+  20: uint32,
+  24: uint64,
+  32: int64,
+  40: double,
+  48: float,
+  56: int64,
+  64: int64,
+  72: int64,
+  80: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm64_linux.expect
new file mode 100644
index 0000000..ca69b6c
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm64_linux.expect
@@ -0,0 +1,17 @@
+Compound(size: 88, field alignment: 8, stack alignment: 8, members: {
+  0: int8,
+  2: int16,
+  4: int32,
+  8: int64,
+  16: uint8,
+  18: uint16,
+  20: uint32,
+  24: uint64,
+  32: int64,
+  40: double,
+  48: float,
+  56: int64,
+  64: int64,
+  72: int64,
+  80: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm64_macos.expect
new file mode 100644
index 0000000..ca69b6c
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm64_macos.expect
@@ -0,0 +1,17 @@
+Compound(size: 88, field alignment: 8, stack alignment: 8, members: {
+  0: int8,
+  2: int16,
+  4: int32,
+  8: int64,
+  16: uint8,
+  18: uint16,
+  20: uint32,
+  24: uint64,
+  32: int64,
+  40: double,
+  48: float,
+  56: int64,
+  64: int64,
+  72: int64,
+  80: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm_android.expect
new file mode 100644
index 0000000..124e769
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm_android.expect
@@ -0,0 +1,17 @@
+Compound(size: 72, field alignment: 8, stack alignment: 8, members: {
+  0: int8,
+  2: int16,
+  4: int32,
+  8: int64,
+  16: uint8,
+  18: uint16,
+  20: uint32,
+  24: uint64,
+  32: int32,
+  40: double,
+  48: float,
+  52: int32,
+  56: int32,
+  60: int32,
+  64: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm_ios.expect
new file mode 100644
index 0000000..44136f8
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm_ios.expect
@@ -0,0 +1,17 @@
+Compound(size: 64, field alignment: 4, stack alignment: 8, members: {
+  0: int8,
+  2: int16,
+  4: int32,
+  8: int64,
+  16: uint8,
+  18: uint16,
+  20: uint32,
+  24: uint64,
+  32: int32,
+  36: double,
+  44: float,
+  48: int32,
+  52: int32,
+  56: int32,
+  60: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm_linux.expect
new file mode 100644
index 0000000..124e769
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/arm_linux.expect
@@ -0,0 +1,17 @@
+Compound(size: 72, field alignment: 8, stack alignment: 8, members: {
+  0: int8,
+  2: int16,
+  4: int32,
+  8: int64,
+  16: uint8,
+  18: uint16,
+  20: uint32,
+  24: uint64,
+  32: int32,
+  40: double,
+  48: float,
+  52: int32,
+  56: int32,
+  60: int32,
+  64: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/ia32_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/ia32_android.expect
new file mode 100644
index 0000000..24fa174
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/ia32_android.expect
@@ -0,0 +1,17 @@
+Compound(size: 64, field alignment: 4, stack alignment: 4, members: {
+  0: int8,
+  2: int16,
+  4: int32,
+  8: int64,
+  16: uint8,
+  18: uint16,
+  20: uint32,
+  24: uint64,
+  32: int32,
+  36: double,
+  44: float,
+  48: int32,
+  52: int32,
+  56: int32,
+  60: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/ia32_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/ia32_linux.expect
new file mode 100644
index 0000000..24fa174
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/ia32_linux.expect
@@ -0,0 +1,17 @@
+Compound(size: 64, field alignment: 4, stack alignment: 4, members: {
+  0: int8,
+  2: int16,
+  4: int32,
+  8: int64,
+  16: uint8,
+  18: uint16,
+  20: uint32,
+  24: uint64,
+  32: int32,
+  36: double,
+  44: float,
+  48: int32,
+  52: int32,
+  56: int32,
+  60: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/ia32_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/ia32_win.expect
new file mode 100644
index 0000000..e0bd22c
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/ia32_win.expect
@@ -0,0 +1,17 @@
+Compound(size: 72, field alignment: 8, stack alignment: 4, members: {
+  0: int8,
+  2: int16,
+  4: int32,
+  8: int64,
+  16: uint8,
+  18: uint16,
+  20: uint32,
+  24: uint64,
+  32: int32,
+  40: double,
+  48: float,
+  52: int32,
+  56: int32,
+  60: int32,
+  64: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/x64_ios.expect
new file mode 100644
index 0000000..ca69b6c
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/x64_ios.expect
@@ -0,0 +1,17 @@
+Compound(size: 88, field alignment: 8, stack alignment: 8, members: {
+  0: int8,
+  2: int16,
+  4: int32,
+  8: int64,
+  16: uint8,
+  18: uint16,
+  20: uint32,
+  24: uint64,
+  32: int64,
+  40: double,
+  48: float,
+  56: int64,
+  64: int64,
+  72: int64,
+  80: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/x64_linux.expect
new file mode 100644
index 0000000..ca69b6c
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/x64_linux.expect
@@ -0,0 +1,17 @@
+Compound(size: 88, field alignment: 8, stack alignment: 8, members: {
+  0: int8,
+  2: int16,
+  4: int32,
+  8: int64,
+  16: uint8,
+  18: uint16,
+  20: uint32,
+  24: uint64,
+  32: int64,
+  40: double,
+  48: float,
+  56: int64,
+  64: int64,
+  72: int64,
+  80: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/x64_macos.expect
new file mode 100644
index 0000000..ca69b6c
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/x64_macos.expect
@@ -0,0 +1,17 @@
+Compound(size: 88, field alignment: 8, stack alignment: 8, members: {
+  0: int8,
+  2: int16,
+  4: int32,
+  8: int64,
+  16: uint8,
+  18: uint16,
+  20: uint32,
+  24: uint64,
+  32: int64,
+  40: double,
+  48: float,
+  56: int64,
+  64: int64,
+  72: int64,
+  80: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/x64_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/x64_win.expect
new file mode 100644
index 0000000..ca69b6c
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_VeryLargeStruct/x64_win.expect
@@ -0,0 +1,17 @@
+Compound(size: 88, field alignment: 8, stack alignment: 8, members: {
+  0: int8,
+  2: int16,
+  4: int32,
+  8: int64,
+  16: uint8,
+  18: uint16,
+  20: uint32,
+  24: uint64,
+  32: int64,
+  40: double,
+  48: float,
+  56: int64,
+  64: int64,
+  72: int64,
+  80: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm64_android.expect
new file mode 100644
index 0000000..025609f
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm64_android.expect
@@ -0,0 +1,6 @@
+Compound(size: 16, field alignment: 4, stack alignment: 8, members: {
+  0: float,
+  4: float,
+  8: float,
+  12: float
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm64_ios.expect
new file mode 100644
index 0000000..db47a46
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm64_ios.expect
@@ -0,0 +1,6 @@
+Compound(size: 16, field alignment: 4, stack alignment: 4, members: {
+  0: float,
+  4: float,
+  8: float,
+  12: float
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm64_linux.expect
new file mode 100644
index 0000000..025609f
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm64_linux.expect
@@ -0,0 +1,6 @@
+Compound(size: 16, field alignment: 4, stack alignment: 8, members: {
+  0: float,
+  4: float,
+  8: float,
+  12: float
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm64_macos.expect
new file mode 100644
index 0000000..025609f
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm64_macos.expect
@@ -0,0 +1,6 @@
+Compound(size: 16, field alignment: 4, stack alignment: 8, members: {
+  0: float,
+  4: float,
+  8: float,
+  12: float
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm_android.expect
new file mode 100644
index 0000000..db47a46
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm_android.expect
@@ -0,0 +1,6 @@
+Compound(size: 16, field alignment: 4, stack alignment: 4, members: {
+  0: float,
+  4: float,
+  8: float,
+  12: float
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm_ios.expect
new file mode 100644
index 0000000..db47a46
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm_ios.expect
@@ -0,0 +1,6 @@
+Compound(size: 16, field alignment: 4, stack alignment: 4, members: {
+  0: float,
+  4: float,
+  8: float,
+  12: float
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm_linux.expect
new file mode 100644
index 0000000..db47a46
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/arm_linux.expect
@@ -0,0 +1,6 @@
+Compound(size: 16, field alignment: 4, stack alignment: 4, members: {
+  0: float,
+  4: float,
+  8: float,
+  12: float
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/ia32_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/ia32_android.expect
new file mode 100644
index 0000000..db47a46
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/ia32_android.expect
@@ -0,0 +1,6 @@
+Compound(size: 16, field alignment: 4, stack alignment: 4, members: {
+  0: float,
+  4: float,
+  8: float,
+  12: float
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/ia32_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/ia32_linux.expect
new file mode 100644
index 0000000..db47a46
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/ia32_linux.expect
@@ -0,0 +1,6 @@
+Compound(size: 16, field alignment: 4, stack alignment: 4, members: {
+  0: float,
+  4: float,
+  8: float,
+  12: float
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/ia32_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/ia32_win.expect
new file mode 100644
index 0000000..db47a46
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/ia32_win.expect
@@ -0,0 +1,6 @@
+Compound(size: 16, field alignment: 4, stack alignment: 4, members: {
+  0: float,
+  4: float,
+  8: float,
+  12: float
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/x64_ios.expect
new file mode 100644
index 0000000..025609f
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/x64_ios.expect
@@ -0,0 +1,6 @@
+Compound(size: 16, field alignment: 4, stack alignment: 8, members: {
+  0: float,
+  4: float,
+  8: float,
+  12: float
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/x64_linux.expect
new file mode 100644
index 0000000..025609f
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/x64_linux.expect
@@ -0,0 +1,6 @@
+Compound(size: 16, field alignment: 4, stack alignment: 8, members: {
+  0: float,
+  4: float,
+  8: float,
+  12: float
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/x64_macos.expect
new file mode 100644
index 0000000..025609f
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/x64_macos.expect
@@ -0,0 +1,6 @@
+Compound(size: 16, field alignment: 4, stack alignment: 8, members: {
+  0: float,
+  4: float,
+  8: float,
+  12: float
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/x64_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/x64_win.expect
new file mode 100644
index 0000000..025609f
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_floatx4/x64_win.expect
@@ -0,0 +1,6 @@
+Compound(size: 16, field alignment: 4, stack alignment: 8, members: {
+  0: float,
+  4: float,
+  8: float,
+  12: float
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm64_android.expect
new file mode 100644
index 0000000..146893d
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm64_android.expect
@@ -0,0 +1,12 @@
+Compound(size: 10, field alignment: 1, stack alignment: 8, members: {
+  0: int8,
+  1: int8,
+  2: int8,
+  3: int8,
+  4: int8,
+  5: int8,
+  6: int8,
+  7: int8,
+  8: int8,
+  9: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm64_ios.expect
new file mode 100644
index 0000000..146893d
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm64_ios.expect
@@ -0,0 +1,12 @@
+Compound(size: 10, field alignment: 1, stack alignment: 8, members: {
+  0: int8,
+  1: int8,
+  2: int8,
+  3: int8,
+  4: int8,
+  5: int8,
+  6: int8,
+  7: int8,
+  8: int8,
+  9: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm64_linux.expect
new file mode 100644
index 0000000..146893d
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm64_linux.expect
@@ -0,0 +1,12 @@
+Compound(size: 10, field alignment: 1, stack alignment: 8, members: {
+  0: int8,
+  1: int8,
+  2: int8,
+  3: int8,
+  4: int8,
+  5: int8,
+  6: int8,
+  7: int8,
+  8: int8,
+  9: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm64_macos.expect
new file mode 100644
index 0000000..146893d
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm64_macos.expect
@@ -0,0 +1,12 @@
+Compound(size: 10, field alignment: 1, stack alignment: 8, members: {
+  0: int8,
+  1: int8,
+  2: int8,
+  3: int8,
+  4: int8,
+  5: int8,
+  6: int8,
+  7: int8,
+  8: int8,
+  9: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm_android.expect
new file mode 100644
index 0000000..c7c2467
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm_android.expect
@@ -0,0 +1,12 @@
+Compound(size: 10, field alignment: 1, stack alignment: 4, members: {
+  0: int8,
+  1: int8,
+  2: int8,
+  3: int8,
+  4: int8,
+  5: int8,
+  6: int8,
+  7: int8,
+  8: int8,
+  9: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm_ios.expect
new file mode 100644
index 0000000..c7c2467
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm_ios.expect
@@ -0,0 +1,12 @@
+Compound(size: 10, field alignment: 1, stack alignment: 4, members: {
+  0: int8,
+  1: int8,
+  2: int8,
+  3: int8,
+  4: int8,
+  5: int8,
+  6: int8,
+  7: int8,
+  8: int8,
+  9: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm_linux.expect
new file mode 100644
index 0000000..c7c2467
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/arm_linux.expect
@@ -0,0 +1,12 @@
+Compound(size: 10, field alignment: 1, stack alignment: 4, members: {
+  0: int8,
+  1: int8,
+  2: int8,
+  3: int8,
+  4: int8,
+  5: int8,
+  6: int8,
+  7: int8,
+  8: int8,
+  9: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/ia32_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/ia32_android.expect
new file mode 100644
index 0000000..c7c2467
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/ia32_android.expect
@@ -0,0 +1,12 @@
+Compound(size: 10, field alignment: 1, stack alignment: 4, members: {
+  0: int8,
+  1: int8,
+  2: int8,
+  3: int8,
+  4: int8,
+  5: int8,
+  6: int8,
+  7: int8,
+  8: int8,
+  9: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/ia32_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/ia32_linux.expect
new file mode 100644
index 0000000..c7c2467
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/ia32_linux.expect
@@ -0,0 +1,12 @@
+Compound(size: 10, field alignment: 1, stack alignment: 4, members: {
+  0: int8,
+  1: int8,
+  2: int8,
+  3: int8,
+  4: int8,
+  5: int8,
+  6: int8,
+  7: int8,
+  8: int8,
+  9: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/ia32_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/ia32_win.expect
new file mode 100644
index 0000000..c7c2467
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/ia32_win.expect
@@ -0,0 +1,12 @@
+Compound(size: 10, field alignment: 1, stack alignment: 4, members: {
+  0: int8,
+  1: int8,
+  2: int8,
+  3: int8,
+  4: int8,
+  5: int8,
+  6: int8,
+  7: int8,
+  8: int8,
+  9: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/x64_ios.expect
new file mode 100644
index 0000000..146893d
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/x64_ios.expect
@@ -0,0 +1,12 @@
+Compound(size: 10, field alignment: 1, stack alignment: 8, members: {
+  0: int8,
+  1: int8,
+  2: int8,
+  3: int8,
+  4: int8,
+  5: int8,
+  6: int8,
+  7: int8,
+  8: int8,
+  9: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/x64_linux.expect
new file mode 100644
index 0000000..146893d
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/x64_linux.expect
@@ -0,0 +1,12 @@
+Compound(size: 10, field alignment: 1, stack alignment: 8, members: {
+  0: int8,
+  1: int8,
+  2: int8,
+  3: int8,
+  4: int8,
+  5: int8,
+  6: int8,
+  7: int8,
+  8: int8,
+  9: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/x64_macos.expect
new file mode 100644
index 0000000..146893d
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/x64_macos.expect
@@ -0,0 +1,12 @@
+Compound(size: 10, field alignment: 1, stack alignment: 8, members: {
+  0: int8,
+  1: int8,
+  2: int8,
+  3: int8,
+  4: int8,
+  5: int8,
+  6: int8,
+  7: int8,
+  8: int8,
+  9: int8
+})
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/x64_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/x64_win.expect
new file mode 100644
index 0000000..146893d
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct_int8x10/x64_win.expect
@@ -0,0 +1,12 @@
+Compound(size: 10, field alignment: 1, stack alignment: 8, members: {
+  0: int8,
+  1: int8,
+  2: int8,
+  3: int8,
+  4: int8,
+  5: int8,
+  6: int8,
+  7: int8,
+  8: int8,
+  9: int8
+})
diff --git a/runtime/vm/constants_ia32.h b/runtime/vm/constants_ia32.h
index 1827e82..eba92da 100644
--- a/runtime/vm/constants_ia32.h
+++ b/runtime/vm/constants_ia32.h
@@ -285,7 +285,7 @@
       kAlignedToWordSize;
 
   // How fields in composites are aligned.
-#if defined(_WIN32)
+#if defined(TARGET_OS_WINDOWS)
   static constexpr AlignmentStrategy kFieldAlignment = kAlignedToValueSize;
 #else
   static constexpr AlignmentStrategy kFieldAlignment =
diff --git a/runtime/vm/symbols.h b/runtime/vm/symbols.h
index 0a40d7d..a1db78b 100644
--- a/runtime/vm/symbols.h
+++ b/runtime/vm/symbols.h
@@ -493,7 +493,8 @@
   V(vm_non_nullable_result_type, "vm:non-nullable-result-type")                \
   V(vm_recognized, "vm:recognized")                                            \
   V(vm_trace_entrypoints, "vm:testing.unsafe.trace-entrypoints-fn")            \
-  V(vm_procedure_attributes_metadata, "vm.procedure-attributes.metadata")
+  V(vm_procedure_attributes_metadata, "vm.procedure-attributes.metadata")      \
+  V(vm_ffi_struct_fields, "vm:ffi:struct-fields")
 
 // Contains a list of frequently used strings in a canonicalized form. This
 // list is kept in the vm_isolate in order to share the copy across isolates
diff --git a/tools/VERSION b/tools/VERSION
index 3545891..5a845c02 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 12
 PATCH 0
-PRERELEASE 56
+PRERELEASE 57
 PRERELEASE_PATCH 0
\ No newline at end of file