diff --git a/pkg/analysis_server/lib/src/domain_completion.dart b/pkg/analysis_server/lib/src/domain_completion.dart
index 98e3a03..0aafdda 100644
--- a/pkg/analysis_server/lib/src/domain_completion.dart
+++ b/pkg/analysis_server/lib/src/domain_completion.dart
@@ -20,6 +20,7 @@
 import 'package:analysis_server/src/services/completion/yaml/analysis_options_generator.dart';
 import 'package:analysis_server/src/services/completion/yaml/fix_data_generator.dart';
 import 'package:analysis_server/src/services/completion/yaml/pubspec_generator.dart';
+import 'package:analysis_server/src/services/completion/yaml/yaml_completion_generator.dart';
 import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer/dart/analysis/session.dart';
 import 'package:analyzer/exception/exception.dart';
@@ -150,7 +151,7 @@
 
   /// Return the suggestions that should be presented in the YAML [file] at the
   /// given [offset].
-  List<CompletionSuggestion> computeYamlSuggestions(String file, int offset) {
+  YamlCompletionResults computeYamlSuggestions(String file, int offset) {
     var provider = server.resourceProvider;
     if (AnalysisEngine.isAnalysisOptionsFileName(file)) {
       var generator = AnalysisOptionsGenerator(provider);
@@ -164,7 +165,7 @@
       var generator = FixDataGenerator(provider);
       return generator.getSuggestions(file, offset);
     }
-    return <CompletionSuggestion>[];
+    return const YamlCompletionResults.empty();
   }
 
   /// Process a `completion.getSuggestionDetails` request.
@@ -325,11 +326,12 @@
         server.sendResponse(CompletionGetSuggestionsResult(completionId)
             .toResponse(request.id));
         // Send a notification with results.
+        final suggestions = computeYamlSuggestions(file, offset);
         sendCompletionNotification(
           completionId,
-          0, // replacementOffset
-          0, // replacementLength,
-          computeYamlSuggestions(file, offset),
+          suggestions.replacementOffset,
+          suggestions.replacementLength,
+          suggestions.suggestions,
           null,
           null,
           null,
diff --git a/pkg/analysis_server/lib/src/lsp/handlers/handler_completion.dart b/pkg/analysis_server/lib/src/lsp/handlers/handler_completion.dart
index 88c5e97..c0b5988 100644
--- a/pkg/analysis_server/lib/src/lsp/handlers/handler_completion.dart
+++ b/pkg/analysis_server/lib/src/lsp/handlers/handler_completion.dart
@@ -16,8 +16,13 @@
 import 'package:analysis_server/src/services/completion/completion_performance.dart';
 import 'package:analysis_server/src/services/completion/dart/completion_manager.dart';
 import 'package:analysis_server/src/services/completion/filtering/fuzzy_matcher.dart';
+import 'package:analysis_server/src/services/completion/yaml/analysis_options_generator.dart';
+import 'package:analysis_server/src/services/completion/yaml/fix_data_generator.dart';
+import 'package:analysis_server/src/services/completion/yaml/pubspec_generator.dart';
+import 'package:analysis_server/src/services/completion/yaml/yaml_completion_generator.dart';
 import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer/source/line_info.dart';
+import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/services/available_declarations.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
 import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
@@ -89,18 +94,47 @@
         await lineInfo.mapResult((lineInfo) => toOffset(lineInfo, pos));
 
     return offset.mapResult((offset) async {
-      // For server results we need a valid unit, but if we don't have one
-      // we shouldn't consider this an error when merging with plugin results.
-      final serverResultsFuture = unit.isError
-          ? Future.value(success(const <CompletionItem>[]))
-          : _getServerItems(
-              completionCapabilities,
-              clientSupportedCompletionKinds,
-              includeSuggestionSets,
-              unit.result,
-              offset,
-              token,
-            );
+      Future<ErrorOr<List<CompletionItem>>> serverResultsFuture;
+      final pathContext = server.resourceProvider.pathContext;
+      final filename = pathContext.basename(path.result);
+      final fileExtension = pathContext.extension(path.result);
+
+      if (fileExtension == '.dart' && !unit.isError) {
+        serverResultsFuture = _getServerDartItems(
+          completionCapabilities,
+          clientSupportedCompletionKinds,
+          includeSuggestionSets,
+          unit.result,
+          offset,
+          token,
+        );
+      } else if (fileExtension == '.yaml') {
+        YamlCompletionGenerator generator;
+        switch (filename) {
+          case AnalysisEngine.PUBSPEC_YAML_FILE:
+            generator = PubspecGenerator(server.resourceProvider);
+            break;
+          case AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE:
+            generator = AnalysisOptionsGenerator(server.resourceProvider);
+            break;
+          case AnalysisEngine.FIX_DATA_FILE:
+            generator = FixDataGenerator(server.resourceProvider);
+            break;
+        }
+        if (generator != null) {
+          serverResultsFuture = _getServerYamlItems(
+            generator,
+            completionCapabilities,
+            clientSupportedCompletionKinds,
+            path.result,
+            lineInfo.result,
+            offset,
+            token,
+          );
+        }
+      }
+
+      serverResultsFuture ??= Future.value(success(const <CompletionItem>[]));
 
       final pluginResultsFuture = _getPluginResults(completionCapabilities,
           clientSupportedCompletionKinds, lineInfo.result, path.result, offset);
@@ -175,7 +209,7 @@
     ).toList());
   }
 
-  Future<ErrorOr<List<CompletionItem>>> _getServerItems(
+  Future<ErrorOr<List<CompletionItem>>> _getServerDartItems(
     CompletionClientCapabilities completionCapabilities,
     HashSet<CompletionItemKind> clientSupportedCompletionKinds,
     bool includeSuggestionSets,
@@ -355,6 +389,33 @@
     });
   }
 
+  Future<ErrorOr<List<CompletionItem>>> _getServerYamlItems(
+    YamlCompletionGenerator generator,
+    CompletionClientCapabilities completionCapabilities,
+    HashSet<CompletionItemKind> clientSupportedCompletionKinds,
+    String path,
+    LineInfo lineInfo,
+    int offset,
+    CancellationToken token,
+  ) async {
+    final suggestions = generator.getSuggestions(path, offset);
+    final completionItems = suggestions.suggestions
+        .map(
+          (item) => toCompletionItem(
+            completionCapabilities,
+            clientSupportedCompletionKinds,
+            lineInfo,
+            item,
+            suggestions.replacementOffset,
+            suggestions.replacementLength,
+            includeCommitCharacters: false,
+            completeFunctionCalls: false,
+          ),
+        )
+        .toList();
+    return success(completionItems);
+  }
+
   Iterable<CompletionItem> _pluginResultsToItems(
     CompletionClientCapabilities completionCapabilities,
     HashSet<CompletionItemKind> clientSupportedCompletionKinds,
diff --git a/pkg/analysis_server/lib/src/lsp/server_capabilities_computer.dart b/pkg/analysis_server/lib/src/lsp/server_capabilities_computer.dart
index fe82284..08e8739 100644
--- a/pkg/analysis_server/lib/src/lsp/server_capabilities_computer.dart
+++ b/pkg/analysis_server/lib/src/lsp/server_capabilities_computer.dart
@@ -242,15 +242,25 @@
         // folders as well.
         .map((glob) => DocumentFilter(scheme: 'file', pattern: '**/$glob'));
 
-    final allTypes = {dartFiles, ...pluginTypes}.toList();
+    final fullySupportedTypes = {dartFiles, ...pluginTypes}.toList();
 
     // Add pubspec + analysis options only for synchronisation. We do not support
     // things like hovers/formatting/etc. for these files so there's no point
     // in having the client send those requests (plus, for things like formatting
     // this could result in the editor reporting "multiple formatters installed"
     // and prevent a built-in YAML formatter from being selected).
-    final allSynchronisedTypes = {
-      ...allTypes,
+    final synchronisedTypes = {
+      ...fullySupportedTypes,
+      pubspecFile,
+      analysisOptionsFile,
+      fixDataFile,
+    }.toList();
+
+    // Completion is supported for some synchronised files that we don't _fully_
+    // support (eg. YAML). If these gain support for things like hover, we may
+    // wish to move them to fullySupprtedTypes but add an exclusion for formatting.
+    final completionSupportedTypes = {
+      ...fullySupportedTypes,
       pubspecFile,
       analysisOptionsFile,
       fixDataFile,
@@ -278,25 +288,25 @@
     register(
       dynamicRegistrations.textSync,
       Method.textDocument_didOpen,
-      TextDocumentRegistrationOptions(documentSelector: allSynchronisedTypes),
+      TextDocumentRegistrationOptions(documentSelector: synchronisedTypes),
     );
     register(
       dynamicRegistrations.textSync,
       Method.textDocument_didClose,
-      TextDocumentRegistrationOptions(documentSelector: allSynchronisedTypes),
+      TextDocumentRegistrationOptions(documentSelector: synchronisedTypes),
     );
     register(
       dynamicRegistrations.textSync,
       Method.textDocument_didChange,
       TextDocumentChangeRegistrationOptions(
           syncKind: TextDocumentSyncKind.Incremental,
-          documentSelector: allSynchronisedTypes),
+          documentSelector: synchronisedTypes),
     );
     register(
       dynamicRegistrations.completion,
       Method.textDocument_completion,
       CompletionRegistrationOptions(
-        documentSelector: allTypes,
+        documentSelector: completionSupportedTypes,
         triggerCharacters: dartCompletionTriggerCharacters,
         allCommitCharacters:
             previewCommitCharacters ? dartCompletionCommitCharacters : null,
@@ -306,13 +316,13 @@
     register(
       dynamicRegistrations.hover,
       Method.textDocument_hover,
-      TextDocumentRegistrationOptions(documentSelector: allTypes),
+      TextDocumentRegistrationOptions(documentSelector: fullySupportedTypes),
     );
     register(
       dynamicRegistrations.signatureHelp,
       Method.textDocument_signatureHelp,
       SignatureHelpRegistrationOptions(
-        documentSelector: allTypes,
+        documentSelector: fullySupportedTypes,
         triggerCharacters: dartSignatureHelpTriggerCharacters,
         retriggerCharacters: dartSignatureHelpRetriggerCharacters,
       ),
@@ -320,22 +330,22 @@
     register(
       dynamicRegistrations.references,
       Method.textDocument_references,
-      TextDocumentRegistrationOptions(documentSelector: allTypes),
+      TextDocumentRegistrationOptions(documentSelector: fullySupportedTypes),
     );
     register(
       dynamicRegistrations.documentHighlights,
       Method.textDocument_documentHighlight,
-      TextDocumentRegistrationOptions(documentSelector: allTypes),
+      TextDocumentRegistrationOptions(documentSelector: fullySupportedTypes),
     );
     register(
       dynamicRegistrations.documentSymbol,
       Method.textDocument_documentSymbol,
-      TextDocumentRegistrationOptions(documentSelector: allTypes),
+      TextDocumentRegistrationOptions(documentSelector: fullySupportedTypes),
     );
     register(
       enableFormatter && dynamicRegistrations.formatting,
       Method.textDocument_formatting,
-      TextDocumentRegistrationOptions(documentSelector: allTypes),
+      TextDocumentRegistrationOptions(documentSelector: fullySupportedTypes),
     );
     register(
       enableFormatter && dynamicRegistrations.typeFormatting,
@@ -356,18 +366,18 @@
     register(
       dynamicRegistrations.definition,
       Method.textDocument_definition,
-      TextDocumentRegistrationOptions(documentSelector: allTypes),
+      TextDocumentRegistrationOptions(documentSelector: fullySupportedTypes),
     );
     register(
       dynamicRegistrations.implementation,
       Method.textDocument_implementation,
-      TextDocumentRegistrationOptions(documentSelector: allTypes),
+      TextDocumentRegistrationOptions(documentSelector: fullySupportedTypes),
     );
     register(
       dynamicRegistrations.codeActions,
       Method.textDocument_codeAction,
       CodeActionRegistrationOptions(
-        documentSelector: allTypes,
+        documentSelector: fullySupportedTypes,
         codeActionKinds: DartCodeActionKind.serverSupportedKinds,
       ),
     );
@@ -375,12 +385,12 @@
       dynamicRegistrations.rename,
       Method.textDocument_rename,
       RenameRegistrationOptions(
-          documentSelector: allTypes, prepareProvider: true),
+          documentSelector: fullySupportedTypes, prepareProvider: true),
     );
     register(
       dynamicRegistrations.folding,
       Method.textDocument_foldingRange,
-      TextDocumentRegistrationOptions(documentSelector: allTypes),
+      TextDocumentRegistrationOptions(documentSelector: fullySupportedTypes),
     );
     register(
       dynamicRegistrations.didChangeConfiguration,
diff --git a/pkg/analysis_server/lib/src/services/completion/yaml/yaml_completion_generator.dart b/pkg/analysis_server/lib/src/services/completion/yaml/yaml_completion_generator.dart
index 3d0b64c..b00768b 100644
--- a/pkg/analysis_server/lib/src/services/completion/yaml/yaml_completion_generator.dart
+++ b/pkg/analysis_server/lib/src/services/completion/yaml/yaml_completion_generator.dart
@@ -24,7 +24,7 @@
 
   /// Return the completion suggestions appropriate for the given [offset] in
   /// the file at the given [filePath].
-  List<CompletionSuggestion> getSuggestions(String filePath, int offset) {
+  YamlCompletionResults getSuggestions(String filePath, int offset) {
     var file = resourceProvider.getFile(filePath);
     String content;
     try {
@@ -32,12 +32,12 @@
     } on FileSystemException {
       // If the file doesn't exist or can't be read, then there are no
       // suggestions.
-      return const <CompletionSuggestion>[];
+      return const YamlCompletionResults.empty();
     }
     var root = _parseYaml(content);
     if (root == null) {
       // If the contents can't be parsed, then there are no suggestions.
-      return const <CompletionSuggestion>[];
+      return const YamlCompletionResults.empty();
     }
     var path = _pathToOffset(root, offset);
     var completionNode = path.last;
@@ -52,17 +52,16 @@
       return getSuggestionsForPath(path, offset);
     }
     // There are no completions at the given location.
-    return const <CompletionSuggestion>[];
+    return const YamlCompletionResults.empty();
   }
 
   /// Given a [path] to the node in which completions are being requested and
   /// the offset of the cursor, return the completions appropriate at that
   /// location.
-  List<CompletionSuggestion> getSuggestionsForPath(
-      List<YamlNode> path, int offset) {
+  YamlCompletionResults getSuggestionsForPath(List<YamlNode> path, int offset) {
     var producer = _producerForPath(path);
     if (producer == null) {
-      return const <CompletionSuggestion>[];
+      return const YamlCompletionResults.empty();
     }
     var invalidSuggestions = _siblingsOnPath(path);
     var suggestions = <CompletionSuggestion>[];
@@ -71,7 +70,12 @@
         suggestions.add(suggestion);
       }
     }
-    return suggestions;
+    final node = path.isNotEmpty ? path.last : null;
+    final replaceNode = node is YamlScalar && node.containsOffset(offset);
+    final replacementOffset = replaceNode ? node.span.start.offset : offset;
+    final replacementLength = replaceNode ? node.span.length : 0;
+    return YamlCompletionResults(
+        suggestions, replacementOffset, replacementLength);
   }
 
   /// Return the result of parsing the file [content] into a YAML node.
@@ -164,6 +168,20 @@
   }
 }
 
+class YamlCompletionResults {
+  final List<CompletionSuggestion> suggestions;
+  final int replacementOffset;
+  final int replacementLength;
+
+  const YamlCompletionResults(
+      this.suggestions, this.replacementOffset, this.replacementLength);
+
+  const YamlCompletionResults.empty()
+      : suggestions = const [],
+        replacementOffset = 0,
+        replacementLength = 0;
+}
+
 extension on YamlMap {
   /// Return the node representing the key that corresponds to the value
   /// represented by the [value] node.
diff --git a/pkg/analysis_server/test/lsp/completion_test.dart b/pkg/analysis_server/test/lsp/completion_dart_test.dart
similarity index 100%
rename from pkg/analysis_server/test/lsp/completion_test.dart
rename to pkg/analysis_server/test/lsp/completion_dart_test.dart
diff --git a/pkg/analysis_server/test/lsp/completion_yaml_test.dart b/pkg/analysis_server/test/lsp/completion_yaml_test.dart
new file mode 100644
index 0000000..0802d65
--- /dev/null
+++ b/pkg/analysis_server/test/lsp/completion_yaml_test.dart
@@ -0,0 +1,302 @@
+// 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:linter/src/rules.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'server_abstract.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(PubspecCompletionTest);
+    defineReflectiveTests(AnalysisOptionsCompletionTest);
+    defineReflectiveTests(FixDataCompletionTest);
+  });
+}
+
+@reflectiveTest
+class AnalysisOptionsCompletionTest extends AbstractLspAnalysisServerTest
+    with CompletionTestMixin {
+  @override
+  void setUp() {
+    registerLintRules();
+    super.setUp();
+  }
+
+  Future<void> test_nested() async {
+    final content = '''
+linter:
+  rules:
+    - ^''';
+
+    final expected = '''
+linter:
+  rules:
+    - annotate_overrides''';
+
+    await verifyCompletions(
+      analysisOptionsUri,
+      content,
+      expectCompletions: [
+        'always_declare_return_types',
+        'annotate_overrides',
+      ],
+      verifyEditsFor: 'annotate_overrides',
+      expectedContent: expected,
+    );
+  }
+
+  Future<void> test_nested_prefix() async {
+    final content = '''
+linter:
+  rules:
+    - ann^''';
+
+    final expected = '''
+linter:
+  rules:
+    - annotate_overrides''';
+
+    await verifyCompletions(
+      analysisOptionsUri,
+      content,
+      expectCompletions: ['annotate_overrides'],
+      verifyEditsFor: 'annotate_overrides',
+      expectedContent: expected,
+    );
+  }
+
+  Future<void> test_topLevel() async {
+    final content = '''
+^''';
+    final expected = '''
+linter: ''';
+
+    await verifyCompletions(
+      analysisOptionsUri,
+      content,
+      expectCompletions: ['linter: '],
+      verifyEditsFor: 'linter: ',
+      expectedContent: expected,
+    );
+  }
+
+  Future<void> test_topLevel_prefix() async {
+    final content = '''
+li^''';
+    final expected = '''
+linter: ''';
+
+    await verifyCompletions(
+      analysisOptionsUri,
+      content,
+      expectCompletions: ['linter: '],
+      verifyEditsFor: 'linter: ',
+      expectedContent: expected,
+    );
+  }
+}
+
+mixin CompletionTestMixin on AbstractLspAnalysisServerTest {
+  Future<void> verifyCompletions(
+    Uri fileUri,
+    String content, {
+    List<String> expectCompletions,
+    String verifyEditsFor,
+    String expectedContent,
+  }) async {
+    await initialize();
+    await openFile(fileUri, withoutMarkers(content));
+    final res = await getCompletion(fileUri, positionFromMarker(content));
+
+    for (final expectedCompletion in expectCompletions) {
+      expect(
+        res.any((c) => c.label == expectedCompletion),
+        isTrue,
+        reason:
+            '"$expectedCompletion" was not in ${res.map((c) => '"${c.label}"')}',
+      );
+    }
+
+    // Check the edits apply correctly.
+    if (verifyEditsFor != null) {
+      final item = res.singleWhere((c) => c.label == verifyEditsFor);
+      expect(item.insertTextFormat, isNull);
+      expect(item.insertText, isNull);
+      final updated = applyTextEdits(withoutMarkers(content), [item.textEdit]);
+      expect(updated, equals(expectedContent));
+    }
+  }
+}
+
+@reflectiveTest
+class FixDataCompletionTest extends AbstractLspAnalysisServerTest
+    with CompletionTestMixin {
+  Uri fixDataUri;
+
+  @override
+  void setUp() {
+    super.setUp();
+    fixDataUri = Uri.file(join(projectFolderPath, 'lib', 'fix_data.yaml'));
+  }
+
+  Future<void> test_nested() async {
+    final content = '''
+version: 1.0.0
+transforms:
+  - changes:
+    - ^''';
+    final expected = '''
+version: 1.0.0
+transforms:
+  - changes:
+    - kind: ''';
+
+    await verifyCompletions(
+      fixDataUri,
+      content,
+      expectCompletions: ['kind: '],
+      verifyEditsFor: 'kind: ',
+      expectedContent: expected,
+    );
+  }
+
+  Future<void> test_nested_prefix() async {
+    final content = '''
+version: 1.0.0
+transforms:
+  - changes:
+    - ki^''';
+    final expected = '''
+version: 1.0.0
+transforms:
+  - changes:
+    - kind: ''';
+
+    await verifyCompletions(
+      fixDataUri,
+      content,
+      expectCompletions: ['kind: '],
+      verifyEditsFor: 'kind: ',
+      expectedContent: expected,
+    );
+  }
+
+  Future<void> test_topLevel() async {
+    final content = '''
+version: 1.0.0
+^''';
+    final expected = '''
+version: 1.0.0
+transforms:''';
+
+    await verifyCompletions(
+      fixDataUri,
+      content,
+      expectCompletions: ['transforms:'],
+      verifyEditsFor: 'transforms:',
+      expectedContent: expected,
+    );
+  }
+
+  Future<void> test_topLevel_prefix() async {
+    final content = '''
+tra^''';
+    final expected = '''
+transforms:''';
+
+    await verifyCompletions(
+      fixDataUri,
+      content,
+      expectCompletions: ['transforms:'],
+      verifyEditsFor: 'transforms:',
+      expectedContent: expected,
+    );
+  }
+}
+
+@reflectiveTest
+class PubspecCompletionTest extends AbstractLspAnalysisServerTest
+    with CompletionTestMixin {
+  Future<void> test_nested() async {
+    final content = '''
+name: foo
+version: 1.0.0
+
+environment:
+  ^''';
+
+    final expected = '''
+name: foo
+version: 1.0.0
+
+environment:
+  sdk: ''';
+
+    await verifyCompletions(
+      pubspecFileUri,
+      content,
+      expectCompletions: ['flutter: ', 'sdk: '],
+      verifyEditsFor: 'sdk: ',
+      expectedContent: expected,
+    );
+  }
+
+  Future<void> test_nested_prefix() async {
+    final content = '''
+name: foo
+version: 1.0.0
+
+environment:
+  sd^''';
+
+    final expected = '''
+name: foo
+version: 1.0.0
+
+environment:
+  sdk: ''';
+
+    await verifyCompletions(
+      pubspecFileUri,
+      content,
+      expectCompletions: ['flutter: ', 'sdk: '],
+      verifyEditsFor: 'sdk: ',
+      expectedContent: expected,
+    );
+  }
+
+  Future<void> test_topLevel() async {
+    final content = '''
+version: 1.0.0
+^''';
+    final expected = '''
+version: 1.0.0
+name: ''';
+
+    await verifyCompletions(
+      pubspecFileUri,
+      content,
+      expectCompletions: ['name: ', 'description: '],
+      verifyEditsFor: 'name: ',
+      expectedContent: expected,
+    );
+  }
+
+  Future<void> test_topLevel_prefix() async {
+    final content = '''
+na^''';
+    final expected = '''
+name: ''';
+
+    await verifyCompletions(
+      pubspecFileUri,
+      content,
+      expectCompletions: ['name: ', 'description: '],
+      verifyEditsFor: 'name: ',
+      expectedContent: expected,
+    );
+  }
+}
diff --git a/pkg/analysis_server/test/lsp/test_all.dart b/pkg/analysis_server/test/lsp/test_all.dart
index 628b142..ea56793 100644
--- a/pkg/analysis_server/test/lsp/test_all.dart
+++ b/pkg/analysis_server/test/lsp/test_all.dart
@@ -13,7 +13,8 @@
 import 'code_actions_fixes_test.dart' as code_actions_fixes;
 import 'code_actions_refactor_test.dart' as code_actions_refactor;
 import 'code_actions_source_test.dart' as code_actions_source;
-import 'completion_test.dart' as completion;
+import 'completion_dart_test.dart' as completion_dart;
+import 'completion_yaml_test.dart' as completion_yaml;
 import 'configuration_test.dart' as configuration;
 import 'definition_test.dart' as definition;
 import 'diagnostic_test.dart' as diagnostic;
@@ -48,7 +49,8 @@
     code_actions_fixes.main();
     code_actions_source.main();
     code_actions_refactor.main();
-    completion.main();
+    completion_dart.main();
+    completion_yaml.main();
     configuration.main();
     definition.main();
     diagnostic.main();
diff --git a/pkg/analysis_server/test/src/services/completion/yaml/yaml_generator_test_support.dart b/pkg/analysis_server/test/src/services/completion/yaml/yaml_generator_test_support.dart
index 7e4cc84..3baebe1 100644
--- a/pkg/analysis_server/test/src/services/completion/yaml/yaml_generator_test_support.dart
+++ b/pkg/analysis_server/test/src/services/completion/yaml/yaml_generator_test_support.dart
@@ -59,6 +59,6 @@
     // Add the file to the file system.
     var file = newFile('/home/test/$fileName', content: content);
     // Generate completions.
-    results = generator.getSuggestions(file.path, completionOffset);
+    results = generator.getSuggestions(file.path, completionOffset).suggestions;
   }
 }
diff --git a/pkg/front_end/test/scanner_fasta_test.dart b/pkg/front_end/test/scanner_fasta_test.dart
index ea17792..08f0bc6 100644
--- a/pkg/front_end/test/scanner_fasta_test.dart
+++ b/pkg/front_end/test/scanner_fasta_test.dart
@@ -8,11 +8,8 @@
 import 'package:_fe_analyzer_shared/src/scanner/scanner.dart'
     as usedForFuzzTesting;
 import 'package:_fe_analyzer_shared/src/scanner/scanner.dart';
-import 'package:_fe_analyzer_shared/src/scanner/string_scanner.dart' as fasta;
 import 'package:_fe_analyzer_shared/src/scanner/token.dart' as fasta;
 import 'package:_fe_analyzer_shared/src/scanner/token_constants.dart' as fasta;
-import 'package:_fe_analyzer_shared/src/scanner/utf8_bytes_scanner.dart'
-    as fasta;
 import 'package:_fe_analyzer_shared/src/scanner/errors.dart';
 import 'package:_fe_analyzer_shared/src/scanner/token.dart';
 import 'package:front_end/src/fasta/fasta_codes.dart';
diff --git a/pkg/frontend_server/lib/src/to_string_transformer.dart b/pkg/frontend_server/lib/src/to_string_transformer.dart
new file mode 100644
index 0000000..8969e51
--- /dev/null
+++ b/pkg/frontend_server/lib/src/to_string_transformer.dart
@@ -0,0 +1,94 @@
+// 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:kernel/ast.dart';
+import 'package:kernel/visitor.dart';
+import '../frontend_server.dart';
+
+// Transformer/visitor for toString
+// If we add any more of these, they really should go into a separate library.
+
+/// A [RecursiveVisitor] that replaces [Object.toString] overrides with
+/// `super.toString()`.
+class ToStringVisitor extends RecursiveVisitor<void> {
+  /// The [packageUris] must not be null.
+  ToStringVisitor(this._packageUris) : assert(_packageUris != null);
+
+  /// A set of package URIs to apply this transformer to, e.g. 'dart:ui' and
+  /// 'package:flutter/foundation.dart'.
+  final Set<String> _packageUris;
+
+  /// Turn 'dart:ui' into 'dart:ui', or
+  /// 'package:flutter/src/semantics_event.dart' into 'package:flutter'.
+  String _importUriToPackage(Uri importUri) =>
+      '${importUri.scheme}:${importUri.pathSegments.first}';
+
+  bool _isInTargetPackage(Procedure node) {
+    return _packageUris
+        .contains(_importUriToPackage(node.enclosingLibrary.importUri));
+  }
+
+  bool _hasKeepAnnotation(Procedure node) {
+    for (ConstantExpression expression
+        in node.annotations.whereType<ConstantExpression>()) {
+      if (expression.constant is! InstanceConstant) {
+        continue;
+      }
+      final InstanceConstant constant = expression.constant as InstanceConstant;
+      if (constant.classNode.name == '_KeepToString' &&
+          constant.classNode.enclosingLibrary.importUri.toString() ==
+              'dart:ui') {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @override
+  void visitProcedure(Procedure node) {
+    if (node.name.text == 'toString' &&
+        node.enclosingClass != null &&
+        node.enclosingLibrary != null &&
+        !node.isStatic &&
+        !node.isAbstract &&
+        !node.enclosingClass.isEnum &&
+        _isInTargetPackage(node) &&
+        !_hasKeepAnnotation(node)) {
+      node.function.body.replaceWith(
+        ReturnStatement(
+          SuperMethodInvocation(
+            node.name,
+            Arguments(<Expression>[]),
+          ),
+        ),
+      );
+    }
+  }
+
+  @override
+  void defaultMember(Member node) {}
+}
+
+/// Replaces [Object.toString] overrides with calls to super for the specified
+/// [packageUris].
+class ToStringTransformer extends ProgramTransformer {
+  /// The [packageUris] parameter must not be null, but may be empty.
+  ToStringTransformer(this._child, this._packageUris)
+      : assert(_packageUris != null);
+
+  final ProgramTransformer _child;
+
+  /// A set of package URIs to apply this transformer to, e.g. 'dart:ui' and
+  /// 'package:flutter/foundation.dart'.
+  final Set<String> _packageUris;
+
+  @override
+  void transform(Component component) {
+    assert(_child is! ToStringTransformer);
+    if (_packageUris.isNotEmpty) {
+      component.visitChildren(ToStringVisitor(_packageUris));
+    }
+    _child?.transform(component);
+  }
+}
diff --git a/runtime/vm/class_id.h b/runtime/vm/class_id.h
index 4c973f4..8421944 100644
--- a/runtime/vm/class_id.h
+++ b/runtime/vm/class_id.h
@@ -352,21 +352,29 @@
 }
 
 inline bool IsFfiTypeClassId(intptr_t index) {
-  // Make sure this is updated when new Ffi types are added.
-  COMPILE_ASSERT(kFfiNativeFunctionCid == kFfiPointerCid + 1 &&
-                 kFfiInt8Cid == kFfiPointerCid + 2 &&
-                 kFfiInt16Cid == kFfiPointerCid + 3 &&
-                 kFfiInt32Cid == kFfiPointerCid + 4 &&
-                 kFfiInt64Cid == kFfiPointerCid + 5 &&
-                 kFfiUint8Cid == kFfiPointerCid + 6 &&
-                 kFfiUint16Cid == kFfiPointerCid + 7 &&
-                 kFfiUint32Cid == kFfiPointerCid + 8 &&
-                 kFfiUint64Cid == kFfiPointerCid + 9 &&
-                 kFfiIntPtrCid == kFfiPointerCid + 10 &&
-                 kFfiFloatCid == kFfiPointerCid + 11 &&
-                 kFfiDoubleCid == kFfiPointerCid + 12 &&
-                 kFfiVoidCid == kFfiPointerCid + 13);
-  return (index >= kFfiPointerCid && index <= kFfiVoidCid);
+  switch (index) {
+    case kFfiPointerCid:
+    case kFfiNativeFunctionCid:
+#define CASE_FFI_CID(name) case kFfi##name##Cid:
+      CLASS_LIST_FFI_TYPE_MARKER(CASE_FFI_CID)
+#undef CASE_FFI_CID
+      return true;
+    default:
+      return false;
+  }
+  UNREACHABLE();
+}
+
+inline bool IsFfiPredefinedClassId(classid_t class_id) {
+  switch (class_id) {
+#define CASE_FFI_CID(name) case kFfi##name##Cid:
+    CLASS_LIST_FFI(CASE_FFI_CID)
+#undef CASE_FFI_CID
+    return true;
+    default:
+      return false;
+  }
+  UNREACHABLE();
 }
 
 inline bool IsFfiTypeIntClassId(intptr_t index) {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.cc b/runtime/vm/compiler/backend/flow_graph_compiler.cc
index 57ba87a..20428a1 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.cc
@@ -3255,8 +3255,10 @@
       !destination.IsFpuRegisters()) {
     // TODO(40209): If this is stack to stack, we could use FpuTMP.
     // Test the impact on code size and speed.
-    EmitNativeMove(destination.Split(zone_, 0), source.Split(zone_, 0), temp);
-    EmitNativeMove(destination.Split(zone_, 1), source.Split(zone_, 1), temp);
+    EmitNativeMove(destination.Split(zone_, 2, 0), source.Split(zone_, 2, 0),
+                   temp);
+    EmitNativeMove(destination.Split(zone_, 2, 1), source.Split(zone_, 2, 1),
+                   temp);
     return;
   }
 
@@ -3331,7 +3333,7 @@
     for (intptr_t i : {0, 1}) {
       const auto& src_split = compiler::ffi::NativeLocation::FromPairLocation(
           zone_, src_loc, src_type, i);
-      EmitNativeMove(dst.Split(zone_, i), src_split, temp);
+      EmitNativeMove(dst.Split(zone_, 2, i), src_split, temp);
     }
   } else {
     const auto& src =
@@ -3351,7 +3353,7 @@
     for (intptr_t i : {0, 1}) {
       const auto& dest_split = compiler::ffi::NativeLocation::FromPairLocation(
           zone_, dst_loc, dst_type, i);
-      EmitNativeMove(dest_split, src.Split(zone_, i), temp);
+      EmitNativeMove(dest_split, src.Split(zone_, 2, i), temp);
     }
   } else {
     const auto& dest =
@@ -3398,7 +3400,7 @@
             compiler::ffi::NativeLocation::FromLocation(zone_, intermediate,
                                                         src_type_split);
         EmitMove(intermediate, src.AsPairLocation()->At(i), temp);
-        EmitNativeMove(dst.Split(zone_, i), intermediate_native, temp);
+        EmitNativeMove(dst.Split(zone_, 2, i), intermediate_native, temp);
       }
     } else {
       const auto& intermediate_native =
diff --git a/runtime/vm/compiler/ffi/native_calling_convention.cc b/runtime/vm/compiler/ffi/native_calling_convention.cc
index 5b21cf2..e53a1e8 100644
--- a/runtime/vm/compiler/ffi/native_calling_convention.cc
+++ b/runtime/vm/compiler/ffi/native_calling_convention.cc
@@ -53,6 +53,13 @@
   return rep;
 }
 
+// The native dual of `kUnboxedFfiIntPtr`.
+//
+// It has the same signedness as `kUnboxedFfiIntPtr` to avoid sign conversions
+// when converting between both.
+const PrimitiveType kFfiIntPtr =
+    compiler::target::kWordSize == 8 ? kInt64 : kUint32;
+
 // Represents the state of a stack frame going into a call, between allocations
 // of argument locations.
 class ArgumentAllocator : public ValueObject {
@@ -62,57 +69,287 @@
   const NativeLocation& AllocateArgument(const NativeType& payload_type) {
     const auto& payload_type_converted = ConvertIfSoftFp(zone_, payload_type);
     if (payload_type_converted.IsFloat()) {
-      const auto kind = FpuRegKind(payload_type);
-      const intptr_t reg_index = FirstFreeFpuRegisterIndex(kind);
-      if (reg_index != kNoFpuRegister) {
-        AllocateFpuRegisterAtIndex(kind, reg_index);
-        if (CallingConventions::kArgumentIntRegXorFpuReg) {
-          cpu_regs_used++;
-        }
-        return *new (zone_) NativeFpuRegistersLocation(
-            payload_type, payload_type, kind, reg_index);
-      } else {
-        BlockAllFpuRegisters();
-        if (CallingConventions::kArgumentIntRegXorFpuReg) {
-          ASSERT(cpu_regs_used == CallingConventions::kNumArgRegs);
-        }
-        // Transfer on stack.
+      return AllocateFloat(payload_type);
+    }
+    if (payload_type_converted.IsInt()) {
+      return AllocateInt(payload_type);
+    }
+
+    // Compounds are laid out differently per ABI, so they are implemented
+    // per ABI.
+    //
+    // Compounds always have a PointerToMemory, Stack, or Multiple location,
+    // even if the parts of a compound fit in 1 cpu or fpu register it will
+    // be nested in a MultipleNativeLocations.
+    const NativeCompoundType& compound_type = payload_type.AsCompound();
+    return AllocateCompound(compound_type);
+  }
+
+ private:
+  const NativeLocation& AllocateFloat(const NativeType& payload_type) {
+    const auto kind = FpuRegKind(payload_type);
+    const intptr_t reg_index = FirstFreeFpuRegisterIndex(kind);
+    if (reg_index != kNoFpuRegister) {
+      AllocateFpuRegisterAtIndex(kind, reg_index);
+      if (CallingConventions::kArgumentIntRegXorFpuReg) {
+        cpu_regs_used++;
       }
-    } else if (payload_type_converted.IsInt()) {
-      // Some calling conventions require the callee to make the lowest 32 bits
-      // in registers non-garbage.
-      const auto& container_type =
-          CallingConventions::kArgumentRegisterExtension == kExtendedTo4
-              ? payload_type_converted.WidenTo4Bytes(zone_)
-              : payload_type_converted;
-      if (target::kWordSize == 4 && payload_type.SizeInBytes() == 8) {
-        if (CallingConventions::kArgumentRegisterAlignment ==
-            kAlignedToWordSizeBut8AlignedTo8) {
-          cpu_regs_used += cpu_regs_used % 2;
-        }
-        if (cpu_regs_used + 2 <= CallingConventions::kNumArgRegs) {
-          const Register register_1 = AllocateCpuRegister();
-          const Register register_2 = AllocateCpuRegister();
-          return *new (zone_) NativeRegistersLocation(
-              zone_, payload_type, container_type, register_1, register_2);
-        }
-      } else {
-        ASSERT(payload_type.SizeInBytes() <= target::kWordSize);
-        if (cpu_regs_used + 1 <= CallingConventions::kNumArgRegs) {
-          return *new (zone_) NativeRegistersLocation(
-              zone_, payload_type, container_type, AllocateCpuRegister());
-        } else {
-          // Transfer on stack.
-        }
+      return *new (zone_) NativeFpuRegistersLocation(payload_type, payload_type,
+                                                     kind, reg_index);
+    }
+
+    BlockAllFpuRegisters();
+    if (CallingConventions::kArgumentIntRegXorFpuReg) {
+      ASSERT(cpu_regs_used == CallingConventions::kNumArgRegs);
+    }
+    return AllocateStack(payload_type);
+  }
+
+  const NativeLocation& AllocateInt(const NativeType& payload_type) {
+    const auto& payload_type_converted = ConvertIfSoftFp(zone_, payload_type);
+
+    // Some calling conventions require the callee to make the lowest 32 bits
+    // in registers non-garbage.
+    const auto& container_type =
+        CallingConventions::kArgumentRegisterExtension == kExtendedTo4
+            ? payload_type_converted.WidenTo4Bytes(zone_)
+            : payload_type_converted;
+    if (target::kWordSize == 4 && payload_type.SizeInBytes() == 8) {
+      if (CallingConventions::kArgumentRegisterAlignment ==
+          kAlignedToWordSizeBut8AlignedTo8) {
+        cpu_regs_used += cpu_regs_used % 2;
+      }
+      if (cpu_regs_used + 2 <= CallingConventions::kNumArgRegs) {
+        const Register register_1 = AllocateCpuRegister();
+        const Register register_2 = AllocateCpuRegister();
+        return *new (zone_) NativeRegistersLocation(
+            zone_, payload_type, container_type, register_1, register_2);
       }
     } else {
-      UNREACHABLE();
+      ASSERT(payload_type.SizeInBytes() <= target::kWordSize);
+      if (cpu_regs_used + 1 <= CallingConventions::kNumArgRegs) {
+        return *new (zone_) NativeRegistersLocation(
+            zone_, payload_type, container_type, AllocateCpuRegister());
+      }
+    }
+    return AllocateStack(payload_type);
+  }
+
+#if defined(TARGET_ARCH_X64) && !defined(TARGET_OS_WINDOWS)
+  // If fits in two fpu and/or cpu registers, transfer in those. Otherwise,
+  // transfer on stack.
+  const NativeLocation& AllocateCompound(
+      const NativeCompoundType& payload_type) {
+    const intptr_t size = payload_type.SizeInBytes();
+    if (size <= 16 && size > 0) {
+      intptr_t required_regs =
+          payload_type.NumberOfWordSizeChunksNotOnlyFloat();
+      intptr_t required_xmm_regs =
+          payload_type.NumberOfWordSizeChunksOnlyFloat();
+      const bool regs_available =
+          cpu_regs_used + required_regs <= CallingConventions::kNumArgRegs;
+      const bool fpu_regs_available =
+          FirstFreeFpuRegisterIndex(kQuadFpuReg) != kNoFpuRegister &&
+          FirstFreeFpuRegisterIndex(kQuadFpuReg) + required_xmm_regs <=
+              CallingConventions::kNumFpuArgRegs;
+      if (regs_available && fpu_regs_available) {
+        // Transfer in registers.
+        NativeLocations& multiple_locations = *new (zone_) NativeLocations(
+            zone_, required_regs + required_xmm_regs);
+        for (intptr_t offset = 0; offset < size;
+             offset += compiler::target::kWordSize) {
+          if (payload_type.ContainsOnlyFloats(
+                  offset, Utils::Minimum<intptr_t>(size - offset, 8))) {
+            const intptr_t reg_index = FirstFreeFpuRegisterIndex(kQuadFpuReg);
+            AllocateFpuRegisterAtIndex(kQuadFpuReg, reg_index);
+            const auto& type = *new (zone_) NativePrimitiveType(kDouble);
+            multiple_locations.Add(new (zone_) NativeFpuRegistersLocation(
+                type, type, kQuadFpuReg, reg_index));
+          } else {
+            const auto& type = *new (zone_) NativePrimitiveType(kInt64);
+            multiple_locations.Add(new (zone_) NativeRegistersLocation(
+                zone_, type, type, AllocateCpuRegister()));
+          }
+        }
+        return *new (zone_)
+            MultipleNativeLocations(payload_type, multiple_locations);
+      }
+    }
+    return AllocateStack(payload_type);
+  }
+#endif  // defined(TARGET_ARCH_X64) && !defined(TARGET_OS_WINDOWS)
+
+#if defined(TARGET_ARCH_X64) && defined(TARGET_OS_WINDOWS)
+  // If struct fits in a single register and size is a power of two, then
+  // use a single register and sign extend.
+  // Otherwise, pass a pointer to a copy.
+  const NativeLocation& AllocateCompound(
+      const NativeCompoundType& payload_type) {
+    const NativeCompoundType& compound_type = payload_type.AsCompound();
+    const intptr_t size = compound_type.SizeInBytes();
+    if (size <= 8 && Utils::IsPowerOfTwo(size)) {
+      if (cpu_regs_used < CallingConventions::kNumArgRegs) {
+        NativeLocations& multiple_locations =
+            *new (zone_) NativeLocations(zone_, 1);
+        const auto& type = *new (zone_) NativePrimitiveType(
+            PrimitiveTypeFromSizeInBytes(size));
+        multiple_locations.Add(new (zone_) NativeRegistersLocation(
+            zone_, type, type, AllocateCpuRegister()));
+        return *new (zone_)
+            MultipleNativeLocations(compound_type, multiple_locations);
+      }
+
+    } else if (size > 0) {
+      // Pointer in register if available, else pointer on stack.
+      const auto& pointer_type = *new (zone_) NativePrimitiveType(kFfiIntPtr);
+      const auto& pointer_location = AllocateArgument(pointer_type);
+      return *new (zone_)
+          PointerToMemoryLocation(pointer_location, compound_type);
     }
 
     return AllocateStack(payload_type);
   }
+#endif  // defined(TARGET_ARCH_X64) && defined(TARGET_OS_WINDOWS)
 
- private:
+#if defined(TARGET_ARCH_IA32)
+  const NativeLocation& AllocateCompound(
+      const NativeCompoundType& payload_type) {
+    return AllocateStack(payload_type);
+  }
+#endif  // defined(TARGET_ARCH_IA32)
+
+#if defined(TARGET_ARCH_ARM)
+  // Transfer homogenuous floats in FPU registers, and allocate the rest
+  // in 4 or 8 size chunks in registers and stack.
+  const NativeLocation& AllocateCompound(
+      const NativeCompoundType& payload_type) {
+    const auto& compound_type = payload_type.AsCompound();
+    if (compound_type.ContainsHomogenuousFloats() && !SoftFpAbi() &&
+        compound_type.members().length() <= 4) {
+      const auto& elem_type = *(compound_type.members().At(0));
+      const intptr_t size = compound_type.SizeInBytes();
+      const intptr_t elem_size = compound_type.members().At(0)->SizeInBytes();
+      const auto reg_kind = FpuRegisterKindFromSize(elem_size);
+      ASSERT(size % elem_size == 0);
+      const intptr_t num_registers = size / elem_size;
+      const intptr_t first_reg =
+          FirstFreeFpuRegisterIndex(reg_kind, num_registers);
+      if (first_reg != kNoFpuRegister) {
+        AllocateFpuRegisterAtIndex(reg_kind, first_reg, num_registers);
+
+        NativeLocations& multiple_locations =
+            *new (zone_) NativeLocations(zone_, num_registers);
+        for (int i = 0; i < num_registers; i++) {
+          const intptr_t reg_index = first_reg + i;
+          multiple_locations.Add(new (zone_) NativeFpuRegistersLocation(
+              elem_type, elem_type, reg_kind, reg_index));
+        }
+        return *new (zone_)
+            MultipleNativeLocations(compound_type, multiple_locations);
+
+      } else {
+        BlockAllFpuRegisters();
+        return AllocateStack(payload_type);
+      }
+    } else {
+      const intptr_t chunck_size = payload_type.AlignmentInBytesStack();
+      ASSERT(chunck_size == 4 || chunck_size == 8);
+      const intptr_t size_rounded =
+          Utils::RoundUp(payload_type.SizeInBytes(), chunck_size);
+      const intptr_t num_chuncks = size_rounded / chunck_size;
+      const auto& chuck_type =
+          *new (zone_) NativePrimitiveType(chunck_size == 4 ? kInt32 : kInt64);
+
+      NativeLocations& multiple_locations =
+          *new (zone_) NativeLocations(zone_, num_chuncks);
+      for (int i = 0; i < num_chuncks; i++) {
+        const auto& allocated_chunk = &AllocateArgument(chuck_type);
+        // The last chunk should not be 8 bytes, if the struct only has 4
+        // remaining bytes to be allocated.
+        if (i == num_chuncks - 1 && chunck_size == 8 &&
+            Utils::RoundUp(payload_type.SizeInBytes(), 4) % 8 == 4) {
+          const auto& small_chuck_type = *new (zone_) NativePrimitiveType(
+              chunck_size == 4 ? kInt32 : kInt64);
+          multiple_locations.Add(&allocated_chunk->WithOtherNativeType(
+              zone_, small_chuck_type, small_chuck_type));
+        } else {
+          multiple_locations.Add(allocated_chunk);
+        }
+      }
+      return *new (zone_)
+          MultipleNativeLocations(compound_type, multiple_locations);
+    }
+  }
+#endif  // defined(TARGET_ARCH_ARM)
+
+#if defined(TARGET_ARCH_ARM64)
+  // Slightly different from Arm32. FPU registers don't alias the same way,
+  // structs up to 16 bytes block remaining registers if they do not fit in
+  // registers, and larger structs go on stack always.
+  const NativeLocation& AllocateCompound(
+      const NativeCompoundType& payload_type) {
+    const auto& compound_type = payload_type.AsCompound();
+    const intptr_t size = compound_type.SizeInBytes();
+    if (compound_type.ContainsHomogenuousFloats() &&
+        compound_type.members().length() <= 4) {
+      const auto& elem_type = *(compound_type.members().At(0));
+      const intptr_t elem_size = compound_type.members().At(0)->SizeInBytes();
+      const auto reg_kind = kQuadFpuReg;
+      ASSERT(size % elem_size == 0);
+      const intptr_t num_registers = size / elem_size;
+      const intptr_t first_reg =
+          FirstFreeFpuRegisterIndex(reg_kind, num_registers);
+      if (first_reg != kNoFpuRegister) {
+        AllocateFpuRegisterAtIndex(reg_kind, first_reg, num_registers);
+
+        NativeLocations& multiple_locations =
+            *new (zone_) NativeLocations(zone_, num_registers);
+        for (int i = 0; i < num_registers; i++) {
+          const intptr_t reg_index = first_reg + i;
+          multiple_locations.Add(new (zone_) NativeFpuRegistersLocation(
+              elem_type, elem_type, reg_kind, reg_index));
+        }
+        return *new (zone_)
+            MultipleNativeLocations(compound_type, multiple_locations);
+      }
+      BlockAllFpuRegisters();
+      return AllocateStack(payload_type);
+    }
+
+    if (size <= 16) {
+      const intptr_t required_regs = size / 8;
+      const bool regs_available =
+          cpu_regs_used + required_regs <= CallingConventions::kNumArgRegs;
+
+      if (regs_available) {
+        const intptr_t size_rounded =
+            Utils::RoundUp(payload_type.SizeInBytes(), 8);
+        const intptr_t num_chuncks = size_rounded / 8;
+        const auto& chuck_type = *new (zone_) NativePrimitiveType(kInt64);
+
+        NativeLocations& multiple_locations =
+            *new (zone_) NativeLocations(zone_, num_chuncks);
+        for (int i = 0; i < num_chuncks; i++) {
+          const auto& allocated_chunk = &AllocateArgument(chuck_type);
+          multiple_locations.Add(allocated_chunk);
+        }
+        return *new (zone_)
+            MultipleNativeLocations(compound_type, multiple_locations);
+
+      } else {
+        // Block all CPU registers.
+        cpu_regs_used = CallingConventions::kNumArgRegs;
+        return AllocateStack(payload_type);
+      }
+    }
+
+    const auto& pointer_location =
+        AllocateArgument(*new (zone_) NativePrimitiveType(kInt64));
+    return *new (zone_)
+        PointerToMemoryLocation(pointer_location, compound_type);
+  }
+#endif  // defined(TARGET_ARCH_ARM64)
+
   static FpuRegisterKind FpuRegKind(const NativeType& payload_type) {
 #if defined(TARGET_ARCH_ARM)
     return FpuRegisterKindFromSize(payload_type.SizeInBytes());
@@ -164,13 +401,13 @@
   }
 
   // If no register is free, returns -1.
-  int FirstFreeFpuRegisterIndex(FpuRegisterKind kind) {
+  int FirstFreeFpuRegisterIndex(FpuRegisterKind kind, int amount = 1) {
     const intptr_t size = SizeFromFpuRegisterKind(kind) / 4;
     ASSERT(size == 1 || size == 2 || size == 4);
     if (fpu_reg_parts_used == -1) return kNoFpuRegister;
-    const intptr_t mask = (1 << size) - 1;
+    const intptr_t mask = (1 << (size * amount)) - 1;
     intptr_t index = 0;
-    while (index < NumFpuRegisters(kind)) {
+    while (index + amount <= NumFpuRegisters(kind)) {
       const intptr_t mask_shifted = mask << (index * size);
       if ((fpu_reg_parts_used & mask_shifted) == 0) {
         return index;
@@ -180,10 +417,12 @@
     return kNoFpuRegister;
   }
 
-  void AllocateFpuRegisterAtIndex(FpuRegisterKind kind, int index) {
+  void AllocateFpuRegisterAtIndex(FpuRegisterKind kind,
+                                  int index,
+                                  int amount = 1) {
     const intptr_t size = SizeFromFpuRegisterKind(kind) / 4;
     ASSERT(size == 1 || size == 2 || size == 4);
-    const intptr_t mask = (1 << size) - 1;
+    const intptr_t mask = (1 << size * amount) - 1;
     const intptr_t mask_shifted = (mask << (index * size));
     ASSERT((mask_shifted & fpu_reg_parts_used) == 0);
     fpu_reg_parts_used |= mask_shifted;
@@ -215,12 +454,24 @@
 // Location for the arguments of a C signature function.
 static NativeLocations& ArgumentLocations(
     Zone* zone,
-    const ZoneGrowableArray<const NativeType*>& arg_reps) {
+    const ZoneGrowableArray<const NativeType*>& arg_reps,
+    const NativeLocation& return_location) {
   intptr_t num_arguments = arg_reps.length();
   auto& result = *new (zone) NativeLocations(zone, num_arguments);
 
   // Loop through all arguments and assign a register or a stack location.
+  // Allocate result pointer for composite returns first.
   ArgumentAllocator frame_state(zone);
+#if !defined(TARGET_ARCH_ARM64)
+  // Arm64 allocates the pointer in R8, which is not an argument location.
+  if (return_location.IsPointerToMemory()) {
+    const auto& pointer_location =
+        return_location.AsPointerToMemory().pointer_location();
+    const auto& pointer_location_allocated =
+        frame_state.AllocateArgument(pointer_location.payload_type());
+    ASSERT(pointer_location.Equals(pointer_location_allocated));
+  }
+#endif
   for (intptr_t i = 0; i < num_arguments; i++) {
     const NativeType& rep = *arg_reps[i];
     result.Add(&frame_state.AllocateArgument(rep));
@@ -228,6 +479,192 @@
   return result;
 }
 
+#if !defined(TARGET_ARCH_IA32)
+static const NativeLocation& PointerToMemoryResultLocation(
+    Zone* zone,
+    const NativeCompoundType& payload_type) {
+  const auto& pointer_type = *new (zone) NativePrimitiveType(kFfiIntPtr);
+  const auto& pointer_location = *new (zone) NativeRegistersLocation(
+      zone, pointer_type, pointer_type,
+      CallingConventions::kPointerToReturnStructRegisterCall);
+  const auto& pointer_return_location = *new (zone) NativeRegistersLocation(
+      zone, pointer_type, pointer_type,
+      CallingConventions::kPointerToReturnStructRegisterReturn);
+  return *new (zone) PointerToMemoryLocation(
+      pointer_location, pointer_return_location, payload_type);
+}
+#endif  // !defined(TARGET_ARCH_IA32)
+
+#if defined(TARGET_ARCH_IA32)
+// ia32 Passes pointers to result locations on the stack.
+static const NativeLocation& PointerToMemoryResultLocation(
+    Zone* zone,
+    const NativeCompoundType& payload_type) {
+  const auto& pointer_type = *new (zone) NativePrimitiveType(kFfiIntPtr);
+  const auto& pointer_location = *new (zone) NativeStackLocation(
+      pointer_type, pointer_type, CallingConventions::kStackPointerRegister, 0);
+  const auto& pointer_return_location = *new (zone) NativeRegistersLocation(
+      zone, pointer_type, pointer_type,
+      CallingConventions::kPointerToReturnStructRegisterReturn);
+  return *new (zone) PointerToMemoryLocation(
+      pointer_location, pointer_return_location, payload_type);
+}
+#endif  // defined(TARGET_ARCH_IA32)
+
+#if defined(TARGET_ARCH_X64) && !defined(TARGET_OS_WINDOWS)
+static const NativeLocation& CompoundResultLocation(
+    Zone* zone,
+    const NativeCompoundType& payload_type) {
+  const intptr_t size = payload_type.SizeInBytes();
+  if (size <= 16 && size > 0) {
+    // Allocate the same as argument, but use return registers instead of
+    // argument registers.
+    NativeLocations& multiple_locations =
+        *new (zone) NativeLocations(zone, size > 8 ? 2 : 1);
+    intptr_t used_regs = 0;
+    intptr_t used_xmm_regs = 0;
+
+    const auto& double_type = *new (zone) NativePrimitiveType(kDouble);
+    const auto& int64_type = *new (zone) NativePrimitiveType(kInt64);
+
+    const bool first_half_in_xmm =
+        payload_type.ContainsOnlyFloats(0, Utils::Minimum<intptr_t>(size, 8));
+    if (first_half_in_xmm) {
+      multiple_locations.Add(new (zone) NativeFpuRegistersLocation(
+          double_type, double_type, kQuadFpuReg,
+          CallingConventions::kReturnFpuReg));
+      used_xmm_regs++;
+    } else {
+      multiple_locations.Add(new (zone) NativeRegistersLocation(
+          zone, int64_type, int64_type, CallingConventions::kReturnReg));
+      used_regs++;
+    }
+    if (size > 8) {
+      const bool second_half_in_xmm = payload_type.ContainsOnlyFloats(
+          8, Utils::Minimum<intptr_t>(size - 8, 8));
+      if (second_half_in_xmm) {
+        const FpuRegister reg = used_xmm_regs == 0
+                                    ? CallingConventions::kReturnFpuReg
+                                    : CallingConventions::kSecondReturnFpuReg;
+        multiple_locations.Add(new (zone) NativeFpuRegistersLocation(
+            double_type, double_type, kQuadFpuReg, reg));
+        used_xmm_regs++;
+      } else {
+        const Register reg = used_regs == 0
+                                 ? CallingConventions::kReturnReg
+                                 : CallingConventions::kSecondReturnReg;
+        multiple_locations.Add(new (zone) NativeRegistersLocation(
+            zone, int64_type, int64_type, reg));
+        used_regs++;
+      }
+    }
+    return *new (zone)
+        MultipleNativeLocations(payload_type, multiple_locations);
+  }
+  return PointerToMemoryResultLocation(zone, payload_type);
+}
+#endif  // defined(TARGET_ARCH_X64) && !defined(TARGET_OS_WINDOWS)
+
+#if defined(TARGET_ARCH_X64) && defined(TARGET_OS_WINDOWS)
+// If struct fits in a single register do that, and sign extend.
+// Otherwise, pass a pointer to memory.
+static const NativeLocation& CompoundResultLocation(
+    Zone* zone,
+    const NativeCompoundType& payload_type) {
+  const intptr_t size = payload_type.SizeInBytes();
+  if (size <= 8 && size > 0 && Utils::IsPowerOfTwo(size)) {
+    NativeLocations& multiple_locations = *new (zone) NativeLocations(zone, 1);
+    const auto& type =
+        *new (zone) NativePrimitiveType(PrimitiveTypeFromSizeInBytes(size));
+    multiple_locations.Add(new (zone) NativeRegistersLocation(
+        zone, type, type, CallingConventions::kReturnReg));
+    return *new (zone)
+        MultipleNativeLocations(payload_type, multiple_locations);
+  }
+  return PointerToMemoryResultLocation(zone, payload_type);
+}
+#endif  // defined(TARGET_ARCH_X64) && defined(TARGET_OS_WINDOWS)
+
+#if defined(TARGET_ARCH_IA32) && !defined(TARGET_OS_WINDOWS)
+static const NativeLocation& CompoundResultLocation(
+    Zone* zone,
+    const NativeCompoundType& payload_type) {
+  return PointerToMemoryResultLocation(zone, payload_type);
+}
+#endif  // defined(TARGET_ARCH_IA32) && !defined(TARGET_OS_WINDOWS)
+
+#if defined(TARGET_ARCH_IA32) && defined(TARGET_OS_WINDOWS)
+// Windows uses up to two return registers, while Linux does not.
+static const NativeLocation& CompoundResultLocation(
+    Zone* zone,
+    const NativeCompoundType& payload_type) {
+  const intptr_t size = payload_type.SizeInBytes();
+  if (size <= 8 && Utils::IsPowerOfTwo(size)) {
+    NativeLocations& multiple_locations =
+        *new (zone) NativeLocations(zone, size > 4 ? 2 : 1);
+    const auto& type = *new (zone) NativePrimitiveType(kUint32);
+    multiple_locations.Add(new (zone) NativeRegistersLocation(
+        zone, type, type, CallingConventions::kReturnReg));
+    if (size > 4) {
+      multiple_locations.Add(new (zone) NativeRegistersLocation(
+          zone, type, type, CallingConventions::kSecondReturnReg));
+    }
+    return *new (zone)
+        MultipleNativeLocations(payload_type, multiple_locations);
+  }
+  return PointerToMemoryResultLocation(zone, payload_type);
+}
+#endif  // defined(TARGET_ARCH_IA32) && defined(TARGET_OS_WINDOWS)
+
+#if defined(TARGET_ARCH_ARM)
+// Arm passes homogenous float return values in FPU registers and small
+// composities in a single integer register. The rest is stored into the
+// location passed in by pointer.
+static const NativeLocation& CompoundResultLocation(
+    Zone* zone,
+    const NativeCompoundType& payload_type) {
+  const intptr_t num_members = payload_type.members().length();
+  if (payload_type.ContainsHomogenuousFloats() && !SoftFpAbi() &&
+      num_members <= 4) {
+    NativeLocations& multiple_locations =
+        *new (zone) NativeLocations(zone, num_members);
+    for (int i = 0; i < num_members; i++) {
+      const auto& member = payload_type.members().At(0)->AsPrimitive();
+      multiple_locations.Add(new (zone) NativeFpuRegistersLocation(
+          member, member, FpuRegisterKindFromSize(member.SizeInBytes()), i));
+    }
+    return *new (zone)
+        MultipleNativeLocations(payload_type, multiple_locations);
+  }
+  const intptr_t size = payload_type.SizeInBytes();
+  if (size <= 4) {
+    NativeLocations& multiple_locations = *new (zone) NativeLocations(zone, 1);
+    const auto& type = *new (zone) NativePrimitiveType(kUint32);
+    multiple_locations.Add(new (zone)
+                               NativeRegistersLocation(zone, type, type, R0));
+    return *new (zone)
+        MultipleNativeLocations(payload_type, multiple_locations);
+  }
+  return PointerToMemoryResultLocation(zone, payload_type);
+}
+#endif  // defined(TARGET_ARCH_ARM)
+
+#if defined(TARGET_ARCH_ARM64)
+// If allocated to integer or fpu registers as argument, same for return,
+// otherwise a pointer to the result location is passed in.
+static const NativeLocation& CompoundResultLocation(
+    Zone* zone,
+    const NativeCompoundType& payload_type) {
+  ArgumentAllocator frame_state(zone);
+  const auto& location_as_argument = frame_state.AllocateArgument(payload_type);
+  if (!location_as_argument.IsStack() &&
+      !location_as_argument.IsPointerToMemory()) {
+    return location_as_argument;
+  }
+  return PointerToMemoryResultLocation(zone, payload_type);
+}
+#endif  // defined(TARGET_ARCH_ARM64)
+
 // Location for the result of a C signature function.
 static const NativeLocation& ResultLocation(Zone* zone,
                                             const NativeType& payload_type) {
@@ -236,29 +673,38 @@
       CallingConventions::kReturnRegisterExtension == kExtendedTo4
           ? payload_type_converted.WidenTo4Bytes(zone)
           : payload_type_converted;
+
   if (container_type.IsFloat()) {
     return *new (zone) NativeFpuRegistersLocation(
         payload_type, container_type, CallingConventions::kReturnFpuReg);
   }
 
-  ASSERT(container_type.IsInt() || container_type.IsVoid());
-  if (container_type.SizeInBytes() == 8 && target::kWordSize == 4) {
+  if (container_type.IsInt() || container_type.IsVoid()) {
+    if (container_type.SizeInBytes() == 8 && target::kWordSize == 4) {
+      return *new (zone) NativeRegistersLocation(
+          zone, payload_type, container_type, CallingConventions::kReturnReg,
+          CallingConventions::kSecondReturnReg);
+    }
+
+    ASSERT(container_type.SizeInBytes() <= target::kWordSize);
     return *new (zone) NativeRegistersLocation(
-        zone, payload_type, container_type, CallingConventions::kReturnReg,
-        CallingConventions::kSecondReturnReg);
+        zone, payload_type, container_type, CallingConventions::kReturnReg);
   }
 
-  ASSERT(container_type.SizeInBytes() <= target::kWordSize);
-  return *new (zone) NativeRegistersLocation(zone, payload_type, container_type,
-                                             CallingConventions::kReturnReg);
+  // Compounds are laid out differently per ABI, so they are implemented
+  // per ABI.
+  const auto& compound_type = payload_type.AsCompound();
+  return CompoundResultLocation(zone, compound_type);
 }
 
 const NativeCallingConvention& NativeCallingConvention::FromSignature(
     Zone* zone,
     const NativeFunctionType& signature) {
-  const auto& argument_locations =
-      ArgumentLocations(zone, signature.argument_types());
+  // With struct return values, a possible pointer to a return value can
+  // occupy an argument position. Hence, allocate return value first.
   const auto& return_location = ResultLocation(zone, signature.return_type());
+  const auto& argument_locations =
+      ArgumentLocations(zone, signature.argument_types(), return_location);
   return *new (zone)
       NativeCallingConvention(argument_locations, return_location);
 }
diff --git a/runtime/vm/compiler/ffi/native_calling_convention_test.cc b/runtime/vm/compiler/ffi/native_calling_convention_test.cc
index aed5fc7..8b27760 100644
--- a/runtime/vm/compiler/ffi/native_calling_convention_test.cc
+++ b/runtime/vm/compiler/ffi/native_calling_convention_test.cc
@@ -80,6 +80,221 @@
   RunSignatureTest(Z, "floatx10", arguments, floatType);
 }
 
+// Test with 3-byte struct.
+//
+// On ia32, result pointer is passed on stack and passed back in eax.
+//
+// On x64, is passed and returned in registers, except for on Windows where it
+// is passed on stack because of its size not being a power of two.
+//
+// See the *.expect in ./unit_tests for this behavior.
+UNIT_TEST_CASE_WITH_ZONE(NativeCallingConvention_struct3bytesx10) {
+  const auto& int8type = *new (Z) NativePrimitiveType(kInt8);
+
+  auto& member_types = *new (Z) NativeTypes(Z, 3);
+  member_types.Add(&int8type);
+  member_types.Add(&int8type);
+  member_types.Add(&int8type);
+  const auto& struct_type =
+      NativeCompoundType::FromNativeTypes(Z, member_types);
+
+  auto& arguments = *new (Z) NativeTypes(Z, 10);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+
+  RunSignatureTest(Z, "struct3bytesx10", arguments, struct_type);
+}
+
+// Test with homogenous struct.
+//
+// On arm softfp, the return pointer is passed in the first int register, and
+// the first struct is passed in the next 3 registers and 1 stack slot.
+//
+// On arm hardfp, arm64, and x64 non-Windows the structs are passed in FPU
+// registers until exhausted, the rest is passed on the stack, and struct is
+// returned in FPU registers.
+//
+// On ia32 a return pointer and all arguments are passed on the stack.
+//
+// On x64 on Windows the structs are passed by pointer and pointer to the
+// return value is passed in.
+//
+// See the *.expect in ./unit_tests for this behavior.
+UNIT_TEST_CASE_WITH_ZONE(NativeCallingConvention_struct16bytesHomogenousx10) {
+  const auto& float_type = *new (Z) NativePrimitiveType(kFloat);
+  const auto& int8type = *new (Z) NativePrimitiveType(kInt8);
+
+  // If passed in FPU registers, uses an even amount of them.
+  auto& member_types = *new (Z) NativeTypes(Z, 4);
+  member_types.Add(&float_type);
+  member_types.Add(&float_type);
+  member_types.Add(&float_type);
+  member_types.Add(&float_type);
+  const auto& struct_type =
+      NativeCompoundType::FromNativeTypes(Z, member_types);
+
+  auto& arguments = *new (Z) NativeTypes(Z, 13);
+  arguments.Add(&struct_type);
+  arguments.Add(&float_type);  // Claim a single FPU register.
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&float_type);   // Check float register back filling, if any.
+  arguments.Add(&int8type);     // Check integer register back filling, if any.
+  arguments.Add(&struct_type);  // Check stack alignment of struct.
+
+  RunSignatureTest(Z, "struct16bytesHomogenousx10", arguments, struct_type);
+}
+
+// A fairly big struct.
+//
+// On arm, split up in 8-byte chunks. The first chunk goes into two registers,
+// the rest on the stack. Note that r1 goes unused and is not backfilled.
+//
+// On arm64 and Windows x64 passed by a pointer to copy.
+//
+// On ia32, wholly passed on stack.
+//
+// On non-Windows x64, wholly passed on stack, and the integer argument
+// backfills a still unoccupied integer register.
+//
+// See the *.expect in ./unit_tests for this behavior.
+UNIT_TEST_CASE_WITH_ZONE(NativeCallingConvention_struct128bytesx1) {
+  const auto& int32_type = *new (Z) NativePrimitiveType(kInt32);
+  const auto& int64_type = *new (Z) NativePrimitiveType(kInt64);
+
+  auto& member_types = *new (Z) NativeTypes(Z, 16);
+  member_types.Add(&int64_type);
+  member_types.Add(&int64_type);
+  member_types.Add(&int64_type);
+  member_types.Add(&int64_type);
+  member_types.Add(&int64_type);
+  member_types.Add(&int64_type);
+  member_types.Add(&int64_type);
+  member_types.Add(&int64_type);
+  member_types.Add(&int64_type);
+  member_types.Add(&int64_type);
+  member_types.Add(&int64_type);
+  member_types.Add(&int64_type);
+  member_types.Add(&int64_type);
+  member_types.Add(&int64_type);
+  member_types.Add(&int64_type);
+  member_types.Add(&int64_type);
+  const auto& struct_type =
+      NativeCompoundType::FromNativeTypes(Z, member_types);
+
+  auto& arguments = *new (Z) NativeTypes(Z, 2);
+  arguments.Add(&struct_type);
+  arguments.Add(&int32_type);  // Check integer register backfilling, if any.
+
+  RunSignatureTest(Z, "struct128bytesx1", arguments, struct_type);
+}
+
+#if defined(TARGET_ARCH_X64)
+// On x64 non-Windows a struct can be spread over an FPU and int register.
+//
+// See the *.expect in ./unit_tests for this behavior.
+UNIT_TEST_CASE_WITH_ZONE(NativeCallingConvention_struct16bytesMixedx10) {
+  const auto& float_type = *new (Z) NativePrimitiveType(kFloat);
+  const auto& int32_type = *new (Z) NativePrimitiveType(kInt32);
+
+  auto& member_types = *new (Z) NativeTypes(Z, 4);
+  member_types.Add(&float_type);
+  member_types.Add(&float_type);
+  member_types.Add(&int32_type);
+  member_types.Add(&int32_type);
+  const auto& struct_type =
+      NativeCompoundType::FromNativeTypes(Z, member_types);
+
+  auto& arguments = *new (Z) NativeTypes(Z, 11);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);  // Integer registers exhausted, on stack.
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&float_type);  // Use remaining FPU register.
+
+  RunSignatureTest(Z, "struct16bytesMixedx10", arguments, struct_type);
+}
+
+// On x64 non-Windows a struct can be spread over an FPU and int register.
+//
+// See the *.expect in ./unit_tests for this behavior.
+UNIT_TEST_CASE_WITH_ZONE(NativeCallingConvention_struct16bytesMixedx10_2) {
+  const auto& float_type = *new (Z) NativePrimitiveType(kFloat);
+  const auto& int32_type = *new (Z) NativePrimitiveType(kInt32);
+
+  auto& member_types = *new (Z) NativeTypes(Z, 4);
+  member_types.Add(&float_type);
+  member_types.Add(&float_type);
+  member_types.Add(&int32_type);
+  member_types.Add(&int32_type);
+  const auto& struct_type =
+      NativeCompoundType::FromNativeTypes(Z, member_types);
+
+  auto& arguments = *new (Z) NativeTypes(Z, 15);
+  arguments.Add(&float_type);
+  arguments.Add(&float_type);
+  arguments.Add(&float_type);
+  arguments.Add(&float_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);  // FPU registers exhausted, on stack.
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&struct_type);
+  arguments.Add(&int32_type);  // Use remaining integer register.
+
+  RunSignatureTest(Z, "struct16bytesMixedx10_2", arguments, struct_type);
+}
+#endif  // defined(TARGET_ARCH_X64)
+
+// On ia32 Windows a struct can be returned in registers, on non-Windows not.
+//
+// See the *.expect in ./unit_tests for this behavior.
+UNIT_TEST_CASE_WITH_ZONE(NativeCallingConvention_struct8bytesx1) {
+  const auto& int8type = *new (Z) NativePrimitiveType(kInt8);
+
+  auto& member_types = *new (Z) NativeTypes(Z, 4);
+  member_types.Add(&int8type);
+  member_types.Add(&int8type);
+  member_types.Add(&int8type);
+  member_types.Add(&int8type);
+  member_types.Add(&int8type);
+  member_types.Add(&int8type);
+  member_types.Add(&int8type);
+  member_types.Add(&int8type);
+  const auto& struct_type =
+      NativeCompoundType::FromNativeTypes(Z, member_types);
+
+  auto& arguments = *new (Z) NativeTypes(Z, 1);
+  arguments.Add(&struct_type);
+
+  RunSignatureTest(Z, "struct8bytesx1", arguments, struct_type);
+}
+
 }  // namespace ffi
 }  // namespace compiler
 }  // namespace dart
diff --git a/runtime/vm/compiler/ffi/native_location.cc b/runtime/vm/compiler/ffi/native_location.cc
index 12439aa..f757a31 100644
--- a/runtime/vm/compiler/ffi/native_location.cc
+++ b/runtime/vm/compiler/ffi/native_location.cc
@@ -24,7 +24,6 @@
       break;
   }
   if (loc.IsPairLocation()) {
-    // TODO(36730): We could possibly consume a pair location as struct.
     return false;
   }
   return false;
@@ -33,7 +32,6 @@
 NativeLocation& NativeLocation::FromLocation(Zone* zone,
                                              Location loc,
                                              Representation rep) {
-  // TODO(36730): We could possibly consume a pair location as struct.
   ASSERT(LocationCanBeExpressed(loc, rep));
 
   const NativeType& native_rep =
@@ -61,7 +59,6 @@
   UNREACHABLE();
 }
 
-// TODO(36730): Remove when being able to consume as struct.
 NativeLocation& NativeLocation::FromPairLocation(Zone* zone,
                                                  Location pair_loc,
                                                  Representation pair_rep,
@@ -92,6 +89,16 @@
   return static_cast<const NativeStackLocation&>(*this);
 }
 
+const MultipleNativeLocations& NativeLocation::AsMultiple() const {
+  ASSERT(IsMultiple());
+  return static_cast<const MultipleNativeLocations&>(*this);
+}
+
+const PointerToMemoryLocation& NativeLocation::AsPointerToMemory() const {
+  ASSERT(IsPointerToMemory());
+  return static_cast<const PointerToMemoryLocation&>(*this);
+}
+
 #if !defined(FFI_UNIT_TESTS)
 Location NativeRegistersLocation::AsLocation() const {
   ASSERT(IsExpressibleAsLocation());
@@ -132,21 +139,46 @@
 #endif
 
 NativeRegistersLocation& NativeRegistersLocation::Split(Zone* zone,
+                                                        intptr_t num_parts,
                                                         intptr_t index) const {
-  ASSERT(num_regs() == 2);
+  ASSERT(num_parts == 2);
+  ASSERT(num_regs() == num_parts);
   return *new (zone) NativeRegistersLocation(
       zone, payload_type().Split(zone, index),
       container_type().Split(zone, index), reg_at(index));
 }
 
 NativeStackLocation& NativeStackLocation::Split(Zone* zone,
+                                                intptr_t num_parts,
                                                 intptr_t index) const {
-  ASSERT(index == 0 || index == 1);
   const intptr_t size = payload_type().SizeInBytes();
 
-  return *new (zone) NativeStackLocation(
-      payload_type().Split(zone, index), container_type().Split(zone, index),
-      base_register_, offset_in_bytes_ + size / 2 * index);
+  if (payload_type().IsPrimitive()) {
+    ASSERT(num_parts == 2);
+    return *new (zone) NativeStackLocation(
+        payload_type().Split(zone, index), container_type().Split(zone, index),
+        base_register_, offset_in_bytes_ + size / num_parts * index);
+  } else {
+    const intptr_t size_rounded_up =
+        Utils::RoundUp(size, compiler::target::kWordSize);
+    ASSERT(size_rounded_up / compiler::target::kWordSize == num_parts);
+
+    // Blocks of compiler::target::kWordSize.
+    return *new (zone) NativeStackLocation(
+        *new (zone) NativePrimitiveType(
+            compiler::target::kWordSize == 8 ? kInt64 : kInt32),
+        *new (zone) NativePrimitiveType(
+            compiler::target::kWordSize == 8 ? kInt64 : kInt32),
+        base_register_, offset_in_bytes_ + compiler::target::kWordSize * index);
+  }
+}
+
+intptr_t MultipleNativeLocations::StackTopInBytes() const {
+  intptr_t height = 0;
+  for (int i = 0; i < locations_.length(); i++) {
+    height = Utils::Maximum(height, locations_[i]->StackTopInBytes());
+  }
+  return height;
 }
 
 NativeLocation& NativeLocation::WidenTo4Bytes(Zone* zone) const {
@@ -210,6 +242,17 @@
   return other_stack.offset_in_bytes_ == offset_in_bytes_;
 }
 
+bool PointerToMemoryLocation::Equals(const NativeLocation& other) const {
+  if (!other.IsPointerToMemory()) {
+    return false;
+  }
+  const auto& other_pointer = other.AsPointerToMemory();
+  if (!other_pointer.pointer_location_.Equals(pointer_location_)) {
+    return false;
+  }
+  return other_pointer.payload_type().Equals(payload_type());
+}
+
 #if !defined(FFI_UNIT_TESTS)
 compiler::Address NativeLocationToStackSlotAddress(
     const NativeStackLocation& loc) {
@@ -219,10 +262,10 @@
 
 static void PrintRepresentations(BaseTextBuffer* f, const NativeLocation& loc) {
   f->AddString(" ");
-  loc.container_type().PrintTo(f);
+  loc.container_type().PrintTo(f, /*multi_line=*/false, /*verbose=*/false);
   if (!loc.container_type().Equals(loc.payload_type())) {
     f->AddString("[");
-    loc.payload_type().PrintTo(f);
+    loc.payload_type().PrintTo(f, /*multi_line=*/false, /*verbose=*/false);
     f->AddString("]");
   }
 }
@@ -238,7 +281,9 @@
   } else {
     f->AddString("(");
     for (intptr_t i = 0; i < num_regs(); i++) {
-      if (i != 0) f->Printf(", ");
+      if (i != 0) {
+        f->Printf(", ");
+      }
       f->Printf("%s", RegisterNames::RegisterName(regs_->At(i)));
     }
     f->AddString(")");
@@ -277,6 +322,27 @@
   return textBuffer.buffer();
 }
 
+void PointerToMemoryLocation::PrintTo(BaseTextBuffer* f) const {
+  f->Printf("P(");
+  pointer_location().PrintTo(f);
+  if (!pointer_location().Equals(pointer_return_location())) {
+    f->Printf(", ret:");
+    pointer_return_location().PrintTo(f);
+  }
+  f->Printf(")");
+  PrintRepresentations(f, *this);
+}
+
+void MultipleNativeLocations::PrintTo(BaseTextBuffer* f) const {
+  f->Printf("M(");
+  for (intptr_t i = 0; i < locations_.length(); i++) {
+    if (i != 0) f->Printf(", ");
+    locations_[i]->PrintTo(f);
+  }
+  f->Printf(")");
+  PrintRepresentations(f, *this);
+}
+
 #if !defined(FFI_UNIT_TESTS)
 const char* NativeLocation::ToCString() const {
   return ToCString(Thread::Current()->zone());
diff --git a/runtime/vm/compiler/ffi/native_location.h b/runtime/vm/compiler/ffi/native_location.h
index 614798a..9108b21 100644
--- a/runtime/vm/compiler/ffi/native_location.h
+++ b/runtime/vm/compiler/ffi/native_location.h
@@ -30,6 +30,8 @@
 class NativeRegistersLocation;
 class NativeFpuRegistersLocation;
 class NativeStackLocation;
+class MultipleNativeLocations;
+class PointerToMemoryLocation;
 
 // NativeLocation objects are used in the FFI to describe argument and return
 // value locations in all native ABIs that the FFI supports.
@@ -95,6 +97,8 @@
   virtual bool IsRegisters() const { return false; }
   virtual bool IsFpuRegisters() const { return false; }
   virtual bool IsStack() const { return false; }
+  virtual bool IsMultiple() const { return false; }
+  virtual bool IsPointerToMemory() const { return false; }
 
   virtual bool IsExpressibleAsLocation() const { return false; }
 #if !defined(FFI_UNIT_TESTS)
@@ -113,13 +117,18 @@
   const NativeRegistersLocation& AsRegisters() const;
   const NativeFpuRegistersLocation& AsFpuRegisters() const;
   const NativeStackLocation& AsStack() const;
+  const MultipleNativeLocations& AsMultiple() const;
+  const PointerToMemoryLocation& AsPointerToMemory() const;
 
-  virtual NativeLocation& Split(Zone* zone, intptr_t index) const {
-    ASSERT(index == 0 || index == 1);
+  // Retrieve one part from this location when it is split into multiple parts.
+  virtual NativeLocation& Split(Zone* zone,
+                                intptr_t num_parts,
+                                intptr_t index) const {
     UNREACHABLE();
   }
 
-  // Return the top of the stack in bytes.
+  // Return the top of the stack in bytes. Recurses over its constituents when
+  // MultipleNativeLocations.
   virtual intptr_t StackTopInBytes() const { return 0; }
 
   // Equality of location, ignores the payload and container native types.
@@ -187,7 +196,9 @@
   intptr_t num_regs() const { return regs_->length(); }
   Register reg_at(intptr_t index) const { return regs_->At(index); }
 
-  virtual NativeRegistersLocation& Split(Zone* zone, intptr_t index) const;
+  virtual NativeRegistersLocation& Split(Zone* zone,
+                                         intptr_t num_parts,
+                                         intptr_t index) const;
 
   virtual void PrintTo(BaseTextBuffer* f) const;
 
@@ -326,7 +337,9 @@
   }
 #endif
 
-  virtual NativeStackLocation& Split(Zone* zone, intptr_t index) const;
+  virtual NativeStackLocation& Split(Zone* zone,
+                                     intptr_t num_parts,
+                                     intptr_t index) const;
 
   virtual intptr_t StackTopInBytes() const {
     return offset_in_bytes() + container_type().SizeInBytes();
@@ -351,6 +364,96 @@
   DISALLOW_COPY_AND_ASSIGN(NativeStackLocation);
 };
 
+// The location of a pointer pointing to a compound.
+//
+// For arguments a pointer to a copy of an object. The backing copy of the
+// object typically resides on the stack.
+//
+// For return values a pointer to empty space that should hold the object. This
+// space also typically resides on the stack.
+class PointerToMemoryLocation : public NativeLocation {
+ public:
+  PointerToMemoryLocation(const NativeLocation& pointer_location,
+                          const NativeCompoundType& object_pointed_to)
+      : NativeLocation(object_pointed_to, object_pointed_to),
+        pointer_location_(pointer_location),
+        pointer_return_location_(pointer_location) {
+    ASSERT(pointer_location.IsRegisters() || pointer_location.IsStack());
+  }
+  PointerToMemoryLocation(const NativeLocation& pointer_location,
+                          const NativeLocation& pointer_return_location,
+                          const NativeCompoundType& object_pointed_to)
+      : NativeLocation(object_pointed_to, object_pointed_to),
+        pointer_location_(pointer_location),
+        pointer_return_location_(pointer_return_location) {
+    ASSERT(pointer_location.IsRegisters() || pointer_location.IsStack());
+  }
+
+  virtual ~PointerToMemoryLocation() {}
+
+  virtual bool IsPointerToMemory() const { return true; }
+
+  virtual void PrintTo(BaseTextBuffer* f) const;
+
+  virtual bool Equals(const NativeLocation& other) const;
+
+  virtual NativeLocation& WithOtherNativeType(
+      Zone* zone,
+      const NativeType& new_payload_type,
+      const NativeType& new_container_type) const {
+    UNREACHABLE();
+  }
+
+  virtual intptr_t StackTopInBytes() const {
+    return pointer_location().StackTopInBytes();
+  }
+
+  // The location where the pointer is passed to the function.
+  const NativeLocation& pointer_location() const { return pointer_location_; }
+
+  // The location where the pointer is returned from the function.
+  const NativeLocation& pointer_return_location() const {
+    return pointer_return_location_;
+  }
+
+ private:
+  const NativeLocation& pointer_location_;
+  // The return location is only in use for return values, not for arguments.
+  const NativeLocation& pointer_return_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(PointerToMemoryLocation);
+};
+
+using NativeLocations = ZoneGrowableArray<const NativeLocation*>;
+
+// A struct broken up over multiple native locations.
+class MultipleNativeLocations : public NativeLocation {
+ public:
+  MultipleNativeLocations(const NativeCompoundType& payload_type,
+                          const NativeLocations& locations)
+      : NativeLocation(payload_type, payload_type), locations_(locations) {}
+  virtual ~MultipleNativeLocations() {}
+
+  virtual bool IsMultiple() const { return true; }
+
+  virtual void PrintTo(BaseTextBuffer* f) const;
+
+  virtual NativeLocation& WithOtherNativeType(
+      Zone* zone,
+      const NativeType& new_payload_type,
+      const NativeType& new_container_type) const {
+    UNREACHABLE();
+  }
+
+  virtual intptr_t StackTopInBytes() const;
+
+  const NativeLocations& locations() const { return locations_; }
+
+ private:
+  const NativeLocations& locations_;
+  DISALLOW_COPY_AND_ASSIGN(MultipleNativeLocations);
+};
+
 #if !defined(FFI_UNIT_TESTS)
 // Return a memory operand for stack slot locations.
 compiler::Address NativeLocationToStackSlotAddress(
diff --git a/runtime/vm/compiler/ffi/native_location_test.cc b/runtime/vm/compiler/ffi/native_location_test.cc
index ea1fb27..8ba10d9 100644
--- a/runtime/vm/compiler/ffi/native_location_test.cc
+++ b/runtime/vm/compiler/ffi/native_location_test.cc
@@ -28,8 +28,8 @@
   const auto& native_location =
       *new (Z) NativeStackLocation(native_type, native_type, SPREG, 0);
 
-  const auto& half_0 = native_location.Split(Z, 0);
-  const auto& half_1 = native_location.Split(Z, 1);
+  const auto& half_0 = native_location.Split(Z, 2, 0);
+  const auto& half_1 = native_location.Split(Z, 2, 1);
 
   EXPECT_EQ(0, half_0.offset_in_bytes());
   EXPECT_EQ(4, half_1.offset_in_bytes());
diff --git a/runtime/vm/compiler/ffi/native_type.cc b/runtime/vm/compiler/ffi/native_type.cc
index 20c33dd..1ffb1a2e 100644
--- a/runtime/vm/compiler/ffi/native_type.cc
+++ b/runtime/vm/compiler/ffi/native_type.cc
@@ -24,6 +24,23 @@
 
 namespace ffi {
 
+PrimitiveType PrimitiveTypeFromSizeInBytes(intptr_t size) {
+  ASSERT(size <= 8);
+  ASSERT(size > 0);
+  switch (size) {
+    case 1:
+      return kUint8;
+    case 2:
+      return kUint16;
+    case 4:
+      return kUint32;
+    case 8:
+      // Dart unboxed Representation for unsigned and signed is equal.
+      return kInt64;
+  }
+  UNREACHABLE();
+}
+
 const NativePrimitiveType& NativeType::AsPrimitive() const {
   ASSERT(IsPrimitive());
   return static_cast<const NativePrimitiveType&>(*this);
@@ -320,20 +337,8 @@
   }
 }
 
-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) {
-  ASSERT(IsPredefinedFfiCid(class_id));
+  ASSERT(IsFfiPredefinedClassId(class_id));
   const auto fundamental_rep = TypeRepresentation(class_id);
   return *new (zone) NativePrimitiveType(fundamental_rep);
 }
@@ -341,7 +346,7 @@
 #if !defined(FFI_UNIT_TESTS)
 NativeType& NativeType::FromAbstractType(Zone* zone, const AbstractType& type) {
   const classid_t class_id = type.type_class_id();
-  if (IsPredefinedFfiCid(class_id)) {
+  if (IsFfiPredefinedClassId(class_id)) {
     return NativeType::FromTypedDataClassId(zone, class_id);
   }
 
@@ -394,15 +399,17 @@
 }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
 
-const char* NativeType::ToCString(Zone* zone, bool multi_line) const {
+const char* NativeType::ToCString(Zone* zone,
+                                  bool multi_line,
+                                  bool verbose) const {
   ZoneTextBuffer textBuffer(zone);
-  PrintTo(&textBuffer, multi_line);
+  PrintTo(&textBuffer, multi_line, verbose);
   return textBuffer.buffer();
 }
 
 #if !defined(FFI_UNIT_TESTS)
-const char* NativeType::ToCString(bool multi_line) const {
-  return ToCString(Thread::Current()->zone(), multi_line);
+const char* NativeType::ToCString() const {
+  return ToCString(Thread::Current()->zone());
 }
 #endif
 
@@ -437,11 +444,15 @@
   }
 }
 
-void NativeType::PrintTo(BaseTextBuffer* f, bool multi_line) const {
+void NativeType::PrintTo(BaseTextBuffer* f,
+                         bool multi_line,
+                         bool verbose) const {
   f->AddString("I");
 }
 
-void NativePrimitiveType::PrintTo(BaseTextBuffer* f, bool multi_line) const {
+void NativePrimitiveType::PrintTo(BaseTextBuffer* f,
+                                  bool multi_line,
+                                  bool verbose) const {
   f->Printf("%s", PrimitiveTypeToCString(representation_));
 }
 
@@ -451,30 +462,35 @@
   return textBuffer.buffer();
 }
 
-void NativeCompoundType::PrintTo(BaseTextBuffer* f, bool multi_line) const {
+void NativeCompoundType::PrintTo(BaseTextBuffer* f,
+                                 bool multi_line,
+                                 bool verbose) 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("size: %" Pd "", SizeInBytes());
+  if (verbose) {
+    f->Printf(", field alignment: %" Pd ", ", AlignmentInBytesField());
+    f->Printf("stack alignment: %" Pd ", ", AlignmentInBytesStack());
+    f->AddString("members: {");
+    if (multi_line) {
+      f->AddString("\n  ");
     }
-    f->Printf("%" Pd ": ", member_offsets_[i]);
-    members_[i]->PrintTo(f);
+    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");
-  }
-  f->AddString("})");
+  f->AddString(")");
   if (multi_line) {
     f->AddString("\n");
   }
diff --git a/runtime/vm/compiler/ffi/native_type.h b/runtime/vm/compiler/ffi/native_type.h
index eaf4129..140c54f 100644
--- a/runtime/vm/compiler/ffi/native_type.h
+++ b/runtime/vm/compiler/ffi/native_type.h
@@ -107,10 +107,14 @@
   // Otherwise, return original representation.
   const NativeType& WidenTo4Bytes(Zone* zone) const;
 
-  virtual void PrintTo(BaseTextBuffer* f, bool multi_line = false) const;
-  const char* ToCString(Zone* zone, bool multi_line = false) const;
+  virtual void PrintTo(BaseTextBuffer* f,
+                       bool multi_line = false,
+                       bool verbose = true) const;
+  const char* ToCString(Zone* zone,
+                        bool multi_line = false,
+                        bool verbose = true) const;
 #if !defined(FFI_UNIT_TESTS)
-  const char* ToCString(bool multi_line = false) const;
+  const char* ToCString() const;
 #endif
 
   virtual ~NativeType() {}
@@ -135,6 +139,8 @@
   // TODO(37470): Add packed data structures.
 };
 
+PrimitiveType PrimitiveTypeFromSizeInBytes(intptr_t size);
+
 // Represents a primitive native type.
 //
 // These are called object types in the C standard (ISO/IEC 9899:2011) and
@@ -167,7 +173,9 @@
   virtual bool Equals(const NativeType& other) const;
   virtual NativePrimitiveType& Split(Zone* zone, intptr_t part) const;
 
-  virtual void PrintTo(BaseTextBuffer* f, bool multi_line = false) const;
+  virtual void PrintTo(BaseTextBuffer* f,
+                       bool multi_line = false,
+                       bool verbose = true) const;
 
   virtual ~NativePrimitiveType() {}
 
@@ -200,7 +208,9 @@
 
   virtual bool Equals(const NativeType& other) const;
 
-  virtual void PrintTo(BaseTextBuffer* f, bool multi_line = false) const;
+  virtual void PrintTo(BaseTextBuffer* f,
+                       bool multi_line = false,
+                       bool verbose = true) const;
 
   // Whether a range within a struct contains only floats.
   //
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm64_android.expect
new file mode 100644
index 0000000..1170c02
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm64_android.expect
@@ -0,0 +1,4 @@
+P(r0 int64) Compound(size: 128)
+r1 int32
+=>
+P(r8 int64) Compound(size: 128)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm64_ios.expect
new file mode 100644
index 0000000..1170c02
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm64_ios.expect
@@ -0,0 +1,4 @@
+P(r0 int64) Compound(size: 128)
+r1 int32
+=>
+P(r8 int64) Compound(size: 128)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm64_linux.expect
new file mode 100644
index 0000000..1170c02
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm64_linux.expect
@@ -0,0 +1,4 @@
+P(r0 int64) Compound(size: 128)
+r1 int32
+=>
+P(r8 int64) Compound(size: 128)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm64_macos.expect
new file mode 100644
index 0000000..1170c02
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm64_macos.expect
@@ -0,0 +1,4 @@
+P(r0 int64) Compound(size: 128)
+r1 int32
+=>
+P(r8 int64) Compound(size: 128)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm_android.expect
new file mode 100644
index 0000000..230a6ab
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm_android.expect
@@ -0,0 +1,4 @@
+M((r2, r3) int64, S+0 int64, S+8 int64, S+16 int64, S+24 int64, S+32 int64, S+40 int64, S+48 int64, S+56 int64, S+64 int64, S+72 int64, S+80 int64, S+88 int64, S+96 int64, S+104 int64, S+112 int64) Compound(size: 128)
+S+120 int32
+=>
+P(r0 uint32) Compound(size: 128)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm_ios.expect
new file mode 100644
index 0000000..230a6ab
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm_ios.expect
@@ -0,0 +1,4 @@
+M((r2, r3) int64, S+0 int64, S+8 int64, S+16 int64, S+24 int64, S+32 int64, S+40 int64, S+48 int64, S+56 int64, S+64 int64, S+72 int64, S+80 int64, S+88 int64, S+96 int64, S+104 int64, S+112 int64) Compound(size: 128)
+S+120 int32
+=>
+P(r0 uint32) Compound(size: 128)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm_linux.expect
new file mode 100644
index 0000000..230a6ab
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/arm_linux.expect
@@ -0,0 +1,4 @@
+M((r2, r3) int64, S+0 int64, S+8 int64, S+16 int64, S+24 int64, S+32 int64, S+40 int64, S+48 int64, S+56 int64, S+64 int64, S+72 int64, S+80 int64, S+88 int64, S+96 int64, S+104 int64, S+112 int64) Compound(size: 128)
+S+120 int32
+=>
+P(r0 uint32) Compound(size: 128)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/ia32_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/ia32_android.expect
new file mode 100644
index 0000000..c765e39
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/ia32_android.expect
@@ -0,0 +1,4 @@
+S+4 Compound(size: 128)
+S+132 int32
+=>
+P(S+0 uint32, ret:eax uint32) Compound(size: 128)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/ia32_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/ia32_linux.expect
new file mode 100644
index 0000000..c765e39
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/ia32_linux.expect
@@ -0,0 +1,4 @@
+S+4 Compound(size: 128)
+S+132 int32
+=>
+P(S+0 uint32, ret:eax uint32) Compound(size: 128)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/ia32_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/ia32_win.expect
new file mode 100644
index 0000000..c765e39
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/ia32_win.expect
@@ -0,0 +1,4 @@
+S+4 Compound(size: 128)
+S+132 int32
+=>
+P(S+0 uint32, ret:eax uint32) Compound(size: 128)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/x64_ios.expect
new file mode 100644
index 0000000..f5ce3da
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/x64_ios.expect
@@ -0,0 +1,4 @@
+S+0 Compound(size: 128)
+rsi int32
+=>
+P(rdi int64, ret:rax int64) Compound(size: 128)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/x64_linux.expect
new file mode 100644
index 0000000..f5ce3da
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/x64_linux.expect
@@ -0,0 +1,4 @@
+S+0 Compound(size: 128)
+rsi int32
+=>
+P(rdi int64, ret:rax int64) Compound(size: 128)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/x64_macos.expect
new file mode 100644
index 0000000..f5ce3da
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/x64_macos.expect
@@ -0,0 +1,4 @@
+S+0 Compound(size: 128)
+rsi int32
+=>
+P(rdi int64, ret:rax int64) Compound(size: 128)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/x64_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/x64_win.expect
new file mode 100644
index 0000000..ff78425
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct128bytesx1/x64_win.expect
@@ -0,0 +1,4 @@
+P(rdx int64) Compound(size: 128)
+r8 int32
+=>
+P(rcx int64, ret:rax int64) Compound(size: 128)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm64_android.expect
new file mode 100644
index 0000000..f4b87ed
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm64_android.expect
@@ -0,0 +1,15 @@
+M(v0 float, v1 float, v2 float, v3 float) Compound(size: 16)
+v4 float
+S+0 Compound(size: 16)
+S+16 Compound(size: 16)
+S+32 Compound(size: 16)
+S+48 Compound(size: 16)
+S+64 Compound(size: 16)
+S+80 Compound(size: 16)
+S+96 Compound(size: 16)
+S+112 Compound(size: 16)
+S+128 float
+r0 int8
+S+136 Compound(size: 16)
+=>
+M(v0 float, v1 float, v2 float, v3 float) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm64_ios.expect
new file mode 100644
index 0000000..70977c2
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm64_ios.expect
@@ -0,0 +1,15 @@
+M(v0 float, v1 float, v2 float, v3 float) Compound(size: 16)
+v4 float
+S+0 Compound(size: 16)
+S+16 Compound(size: 16)
+S+32 Compound(size: 16)
+S+48 Compound(size: 16)
+S+64 Compound(size: 16)
+S+80 Compound(size: 16)
+S+96 Compound(size: 16)
+S+112 Compound(size: 16)
+S+128 float
+r0 int32[int8]
+S+132 Compound(size: 16)
+=>
+M(v0 float, v1 float, v2 float, v3 float) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm64_linux.expect
new file mode 100644
index 0000000..f4b87ed
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm64_linux.expect
@@ -0,0 +1,15 @@
+M(v0 float, v1 float, v2 float, v3 float) Compound(size: 16)
+v4 float
+S+0 Compound(size: 16)
+S+16 Compound(size: 16)
+S+32 Compound(size: 16)
+S+48 Compound(size: 16)
+S+64 Compound(size: 16)
+S+80 Compound(size: 16)
+S+96 Compound(size: 16)
+S+112 Compound(size: 16)
+S+128 float
+r0 int8
+S+136 Compound(size: 16)
+=>
+M(v0 float, v1 float, v2 float, v3 float) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm64_macos.expect
new file mode 100644
index 0000000..f4b87ed
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm64_macos.expect
@@ -0,0 +1,15 @@
+M(v0 float, v1 float, v2 float, v3 float) Compound(size: 16)
+v4 float
+S+0 Compound(size: 16)
+S+16 Compound(size: 16)
+S+32 Compound(size: 16)
+S+48 Compound(size: 16)
+S+64 Compound(size: 16)
+S+80 Compound(size: 16)
+S+96 Compound(size: 16)
+S+112 Compound(size: 16)
+S+128 float
+r0 int8
+S+136 Compound(size: 16)
+=>
+M(v0 float, v1 float, v2 float, v3 float) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm_android.expect
new file mode 100644
index 0000000..24fce41
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm_android.expect
@@ -0,0 +1,15 @@
+M(r1 int32, r2 int32, r3 int32, S+0 int32) Compound(size: 16)
+S+4 float
+M(S+8 int32, S+12 int32, S+16 int32, S+20 int32) Compound(size: 16)
+M(S+24 int32, S+28 int32, S+32 int32, S+36 int32) Compound(size: 16)
+M(S+40 int32, S+44 int32, S+48 int32, S+52 int32) Compound(size: 16)
+M(S+56 int32, S+60 int32, S+64 int32, S+68 int32) Compound(size: 16)
+M(S+72 int32, S+76 int32, S+80 int32, S+84 int32) Compound(size: 16)
+M(S+88 int32, S+92 int32, S+96 int32, S+100 int32) Compound(size: 16)
+M(S+104 int32, S+108 int32, S+112 int32, S+116 int32) Compound(size: 16)
+M(S+120 int32, S+124 int32, S+128 int32, S+132 int32) Compound(size: 16)
+S+136 float
+S+140 int32[int8]
+M(S+144 int32, S+148 int32, S+152 int32, S+156 int32) Compound(size: 16)
+=>
+P(r0 uint32) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm_ios.expect
new file mode 100644
index 0000000..124f1cd
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm_ios.expect
@@ -0,0 +1,15 @@
+M(s0 float, s1 float, s2 float, s3 float) Compound(size: 16)
+s4 float
+M(s5 float, s6 float, s7 float, s8 float) Compound(size: 16)
+M(s9 float, s10 float, s11 float, s12 float) Compound(size: 16)
+S+0 Compound(size: 16)
+S+16 Compound(size: 16)
+S+32 Compound(size: 16)
+S+48 Compound(size: 16)
+S+64 Compound(size: 16)
+S+80 Compound(size: 16)
+S+96 float
+r0 int32[int8]
+S+100 Compound(size: 16)
+=>
+M(s0 float, s1 float, s2 float, s3 float) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm_linux.expect
new file mode 100644
index 0000000..124f1cd
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm_linux.expect
@@ -0,0 +1,15 @@
+M(s0 float, s1 float, s2 float, s3 float) Compound(size: 16)
+s4 float
+M(s5 float, s6 float, s7 float, s8 float) Compound(size: 16)
+M(s9 float, s10 float, s11 float, s12 float) Compound(size: 16)
+S+0 Compound(size: 16)
+S+16 Compound(size: 16)
+S+32 Compound(size: 16)
+S+48 Compound(size: 16)
+S+64 Compound(size: 16)
+S+80 Compound(size: 16)
+S+96 float
+r0 int32[int8]
+S+100 Compound(size: 16)
+=>
+M(s0 float, s1 float, s2 float, s3 float) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/ia32_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/ia32_android.expect
new file mode 100644
index 0000000..3c127f9
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/ia32_android.expect
@@ -0,0 +1,15 @@
+S+4 Compound(size: 16)
+S+20 float
+S+24 Compound(size: 16)
+S+40 Compound(size: 16)
+S+56 Compound(size: 16)
+S+72 Compound(size: 16)
+S+88 Compound(size: 16)
+S+104 Compound(size: 16)
+S+120 Compound(size: 16)
+S+136 Compound(size: 16)
+S+152 float
+S+156 int32[int8]
+S+160 Compound(size: 16)
+=>
+P(S+0 uint32, ret:eax uint32) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/ia32_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/ia32_linux.expect
new file mode 100644
index 0000000..3c127f9
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/ia32_linux.expect
@@ -0,0 +1,15 @@
+S+4 Compound(size: 16)
+S+20 float
+S+24 Compound(size: 16)
+S+40 Compound(size: 16)
+S+56 Compound(size: 16)
+S+72 Compound(size: 16)
+S+88 Compound(size: 16)
+S+104 Compound(size: 16)
+S+120 Compound(size: 16)
+S+136 Compound(size: 16)
+S+152 float
+S+156 int32[int8]
+S+160 Compound(size: 16)
+=>
+P(S+0 uint32, ret:eax uint32) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/ia32_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/ia32_win.expect
new file mode 100644
index 0000000..3c127f9
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/ia32_win.expect
@@ -0,0 +1,15 @@
+S+4 Compound(size: 16)
+S+20 float
+S+24 Compound(size: 16)
+S+40 Compound(size: 16)
+S+56 Compound(size: 16)
+S+72 Compound(size: 16)
+S+88 Compound(size: 16)
+S+104 Compound(size: 16)
+S+120 Compound(size: 16)
+S+136 Compound(size: 16)
+S+152 float
+S+156 int32[int8]
+S+160 Compound(size: 16)
+=>
+P(S+0 uint32, ret:eax uint32) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/x64_ios.expect
new file mode 100644
index 0000000..991a252
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/x64_ios.expect
@@ -0,0 +1,15 @@
+M(xmm0 double, xmm1 double) Compound(size: 16)
+xmm2 float
+M(xmm3 double, xmm4 double) Compound(size: 16)
+M(xmm5 double, xmm6 double) Compound(size: 16)
+S+0 Compound(size: 16)
+S+16 Compound(size: 16)
+S+32 Compound(size: 16)
+S+48 Compound(size: 16)
+S+64 Compound(size: 16)
+S+80 Compound(size: 16)
+xmm7 float
+rdi int32[int8]
+S+96 Compound(size: 16)
+=>
+M(xmm0 double, xmm1 double) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/x64_linux.expect
new file mode 100644
index 0000000..991a252
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/x64_linux.expect
@@ -0,0 +1,15 @@
+M(xmm0 double, xmm1 double) Compound(size: 16)
+xmm2 float
+M(xmm3 double, xmm4 double) Compound(size: 16)
+M(xmm5 double, xmm6 double) Compound(size: 16)
+S+0 Compound(size: 16)
+S+16 Compound(size: 16)
+S+32 Compound(size: 16)
+S+48 Compound(size: 16)
+S+64 Compound(size: 16)
+S+80 Compound(size: 16)
+xmm7 float
+rdi int32[int8]
+S+96 Compound(size: 16)
+=>
+M(xmm0 double, xmm1 double) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/x64_macos.expect
new file mode 100644
index 0000000..991a252
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/x64_macos.expect
@@ -0,0 +1,15 @@
+M(xmm0 double, xmm1 double) Compound(size: 16)
+xmm2 float
+M(xmm3 double, xmm4 double) Compound(size: 16)
+M(xmm5 double, xmm6 double) Compound(size: 16)
+S+0 Compound(size: 16)
+S+16 Compound(size: 16)
+S+32 Compound(size: 16)
+S+48 Compound(size: 16)
+S+64 Compound(size: 16)
+S+80 Compound(size: 16)
+xmm7 float
+rdi int32[int8]
+S+96 Compound(size: 16)
+=>
+M(xmm0 double, xmm1 double) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/x64_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/x64_win.expect
new file mode 100644
index 0000000..8e31945
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/x64_win.expect
@@ -0,0 +1,15 @@
+P(rdx int64) Compound(size: 16)
+xmm2 float
+P(r9 int64) Compound(size: 16)
+P(S+0 int64) Compound(size: 16)
+P(S+8 int64) Compound(size: 16)
+P(S+16 int64) Compound(size: 16)
+P(S+24 int64) Compound(size: 16)
+P(S+32 int64) Compound(size: 16)
+P(S+40 int64) Compound(size: 16)
+P(S+48 int64) Compound(size: 16)
+S+56 float
+S+64 int8
+P(S+72 int64) Compound(size: 16)
+=>
+P(rcx int64, ret:rax int64) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_ios.expect
new file mode 100644
index 0000000..2b50280
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_ios.expect
@@ -0,0 +1,13 @@
+M(xmm0 double, rdi int64) Compound(size: 16)
+M(xmm1 double, rsi int64) Compound(size: 16)
+M(xmm2 double, rdx int64) Compound(size: 16)
+M(xmm3 double, rcx int64) Compound(size: 16)
+M(xmm4 double, r8 int64) Compound(size: 16)
+M(xmm5 double, r9 int64) Compound(size: 16)
+S+0 Compound(size: 16)
+S+16 Compound(size: 16)
+S+32 Compound(size: 16)
+S+48 Compound(size: 16)
+xmm6 float
+=>
+M(xmm0 double, rax int64) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_linux.expect
new file mode 100644
index 0000000..2b50280
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_linux.expect
@@ -0,0 +1,13 @@
+M(xmm0 double, rdi int64) Compound(size: 16)
+M(xmm1 double, rsi int64) Compound(size: 16)
+M(xmm2 double, rdx int64) Compound(size: 16)
+M(xmm3 double, rcx int64) Compound(size: 16)
+M(xmm4 double, r8 int64) Compound(size: 16)
+M(xmm5 double, r9 int64) Compound(size: 16)
+S+0 Compound(size: 16)
+S+16 Compound(size: 16)
+S+32 Compound(size: 16)
+S+48 Compound(size: 16)
+xmm6 float
+=>
+M(xmm0 double, rax int64) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_macos.expect
new file mode 100644
index 0000000..2b50280
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_macos.expect
@@ -0,0 +1,13 @@
+M(xmm0 double, rdi int64) Compound(size: 16)
+M(xmm1 double, rsi int64) Compound(size: 16)
+M(xmm2 double, rdx int64) Compound(size: 16)
+M(xmm3 double, rcx int64) Compound(size: 16)
+M(xmm4 double, r8 int64) Compound(size: 16)
+M(xmm5 double, r9 int64) Compound(size: 16)
+S+0 Compound(size: 16)
+S+16 Compound(size: 16)
+S+32 Compound(size: 16)
+S+48 Compound(size: 16)
+xmm6 float
+=>
+M(xmm0 double, rax int64) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_win.expect
new file mode 100644
index 0000000..d21ee2b
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_win.expect
@@ -0,0 +1,13 @@
+P(rdx int64) Compound(size: 16)
+P(r8 int64) Compound(size: 16)
+P(r9 int64) Compound(size: 16)
+P(S+0 int64) Compound(size: 16)
+P(S+8 int64) Compound(size: 16)
+P(S+16 int64) Compound(size: 16)
+P(S+24 int64) Compound(size: 16)
+P(S+32 int64) Compound(size: 16)
+P(S+40 int64) Compound(size: 16)
+P(S+48 int64) Compound(size: 16)
+S+56 float
+=>
+P(rcx int64, ret:rax int64) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_ios.expect
new file mode 100644
index 0000000..bcdf3b5
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_ios.expect
@@ -0,0 +1,17 @@
+xmm0 float
+xmm1 float
+xmm2 float
+xmm3 float
+M(xmm4 double, rdi int64) Compound(size: 16)
+M(xmm5 double, rsi int64) Compound(size: 16)
+M(xmm6 double, rdx int64) Compound(size: 16)
+M(xmm7 double, rcx int64) Compound(size: 16)
+S+0 Compound(size: 16)
+S+16 Compound(size: 16)
+S+32 Compound(size: 16)
+S+48 Compound(size: 16)
+S+64 Compound(size: 16)
+S+80 Compound(size: 16)
+r8 int32
+=>
+M(xmm0 double, rax int64) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_linux.expect
new file mode 100644
index 0000000..bcdf3b5
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_linux.expect
@@ -0,0 +1,17 @@
+xmm0 float
+xmm1 float
+xmm2 float
+xmm3 float
+M(xmm4 double, rdi int64) Compound(size: 16)
+M(xmm5 double, rsi int64) Compound(size: 16)
+M(xmm6 double, rdx int64) Compound(size: 16)
+M(xmm7 double, rcx int64) Compound(size: 16)
+S+0 Compound(size: 16)
+S+16 Compound(size: 16)
+S+32 Compound(size: 16)
+S+48 Compound(size: 16)
+S+64 Compound(size: 16)
+S+80 Compound(size: 16)
+r8 int32
+=>
+M(xmm0 double, rax int64) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_macos.expect
new file mode 100644
index 0000000..bcdf3b5
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_macos.expect
@@ -0,0 +1,17 @@
+xmm0 float
+xmm1 float
+xmm2 float
+xmm3 float
+M(xmm4 double, rdi int64) Compound(size: 16)
+M(xmm5 double, rsi int64) Compound(size: 16)
+M(xmm6 double, rdx int64) Compound(size: 16)
+M(xmm7 double, rcx int64) Compound(size: 16)
+S+0 Compound(size: 16)
+S+16 Compound(size: 16)
+S+32 Compound(size: 16)
+S+48 Compound(size: 16)
+S+64 Compound(size: 16)
+S+80 Compound(size: 16)
+r8 int32
+=>
+M(xmm0 double, rax int64) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_win.expect
new file mode 100644
index 0000000..bb695c2
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_win.expect
@@ -0,0 +1,17 @@
+xmm1 float
+xmm2 float
+xmm3 float
+S+0 float
+P(S+8 int64) Compound(size: 16)
+P(S+16 int64) Compound(size: 16)
+P(S+24 int64) Compound(size: 16)
+P(S+32 int64) Compound(size: 16)
+P(S+40 int64) Compound(size: 16)
+P(S+48 int64) Compound(size: 16)
+P(S+56 int64) Compound(size: 16)
+P(S+64 int64) Compound(size: 16)
+P(S+72 int64) Compound(size: 16)
+P(S+80 int64) Compound(size: 16)
+S+88 int32
+=>
+P(rcx int64, ret:rax int64) Compound(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_android.expect
new file mode 100644
index 0000000..121dccb
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_android.expect
@@ -0,0 +1,12 @@
+M(r0 int64) Compound(size: 3)
+M(r1 int64) Compound(size: 3)
+M(r2 int64) Compound(size: 3)
+M(r3 int64) Compound(size: 3)
+M(r4 int64) Compound(size: 3)
+M(r5 int64) Compound(size: 3)
+M(r6 int64) Compound(size: 3)
+M(r7 int64) Compound(size: 3)
+M(S+0 int64) Compound(size: 3)
+M(S+8 int64) Compound(size: 3)
+=>
+M(r0 int64) Compound(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_ios.expect
new file mode 100644
index 0000000..121dccb
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_ios.expect
@@ -0,0 +1,12 @@
+M(r0 int64) Compound(size: 3)
+M(r1 int64) Compound(size: 3)
+M(r2 int64) Compound(size: 3)
+M(r3 int64) Compound(size: 3)
+M(r4 int64) Compound(size: 3)
+M(r5 int64) Compound(size: 3)
+M(r6 int64) Compound(size: 3)
+M(r7 int64) Compound(size: 3)
+M(S+0 int64) Compound(size: 3)
+M(S+8 int64) Compound(size: 3)
+=>
+M(r0 int64) Compound(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_linux.expect
new file mode 100644
index 0000000..121dccb
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_linux.expect
@@ -0,0 +1,12 @@
+M(r0 int64) Compound(size: 3)
+M(r1 int64) Compound(size: 3)
+M(r2 int64) Compound(size: 3)
+M(r3 int64) Compound(size: 3)
+M(r4 int64) Compound(size: 3)
+M(r5 int64) Compound(size: 3)
+M(r6 int64) Compound(size: 3)
+M(r7 int64) Compound(size: 3)
+M(S+0 int64) Compound(size: 3)
+M(S+8 int64) Compound(size: 3)
+=>
+M(r0 int64) Compound(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_macos.expect
new file mode 100644
index 0000000..121dccb
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_macos.expect
@@ -0,0 +1,12 @@
+M(r0 int64) Compound(size: 3)
+M(r1 int64) Compound(size: 3)
+M(r2 int64) Compound(size: 3)
+M(r3 int64) Compound(size: 3)
+M(r4 int64) Compound(size: 3)
+M(r5 int64) Compound(size: 3)
+M(r6 int64) Compound(size: 3)
+M(r7 int64) Compound(size: 3)
+M(S+0 int64) Compound(size: 3)
+M(S+8 int64) Compound(size: 3)
+=>
+M(r0 int64) Compound(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_android.expect
new file mode 100644
index 0000000..572a779
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_android.expect
@@ -0,0 +1,12 @@
+M(r0 int32) Compound(size: 3)
+M(r1 int32) Compound(size: 3)
+M(r2 int32) Compound(size: 3)
+M(r3 int32) Compound(size: 3)
+M(S+0 int32) Compound(size: 3)
+M(S+4 int32) Compound(size: 3)
+M(S+8 int32) Compound(size: 3)
+M(S+12 int32) Compound(size: 3)
+M(S+16 int32) Compound(size: 3)
+M(S+20 int32) Compound(size: 3)
+=>
+M(r0 uint32) Compound(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_ios.expect
new file mode 100644
index 0000000..572a779
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_ios.expect
@@ -0,0 +1,12 @@
+M(r0 int32) Compound(size: 3)
+M(r1 int32) Compound(size: 3)
+M(r2 int32) Compound(size: 3)
+M(r3 int32) Compound(size: 3)
+M(S+0 int32) Compound(size: 3)
+M(S+4 int32) Compound(size: 3)
+M(S+8 int32) Compound(size: 3)
+M(S+12 int32) Compound(size: 3)
+M(S+16 int32) Compound(size: 3)
+M(S+20 int32) Compound(size: 3)
+=>
+M(r0 uint32) Compound(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_linux.expect
new file mode 100644
index 0000000..572a779
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_linux.expect
@@ -0,0 +1,12 @@
+M(r0 int32) Compound(size: 3)
+M(r1 int32) Compound(size: 3)
+M(r2 int32) Compound(size: 3)
+M(r3 int32) Compound(size: 3)
+M(S+0 int32) Compound(size: 3)
+M(S+4 int32) Compound(size: 3)
+M(S+8 int32) Compound(size: 3)
+M(S+12 int32) Compound(size: 3)
+M(S+16 int32) Compound(size: 3)
+M(S+20 int32) Compound(size: 3)
+=>
+M(r0 uint32) Compound(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/ia32_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/ia32_android.expect
new file mode 100644
index 0000000..91c0595
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/ia32_android.expect
@@ -0,0 +1,12 @@
+S+4 Compound(size: 3)
+S+8 Compound(size: 3)
+S+12 Compound(size: 3)
+S+16 Compound(size: 3)
+S+20 Compound(size: 3)
+S+24 Compound(size: 3)
+S+28 Compound(size: 3)
+S+32 Compound(size: 3)
+S+36 Compound(size: 3)
+S+40 Compound(size: 3)
+=>
+P(S+0 uint32, ret:eax uint32) Compound(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/ia32_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/ia32_linux.expect
new file mode 100644
index 0000000..91c0595
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/ia32_linux.expect
@@ -0,0 +1,12 @@
+S+4 Compound(size: 3)
+S+8 Compound(size: 3)
+S+12 Compound(size: 3)
+S+16 Compound(size: 3)
+S+20 Compound(size: 3)
+S+24 Compound(size: 3)
+S+28 Compound(size: 3)
+S+32 Compound(size: 3)
+S+36 Compound(size: 3)
+S+40 Compound(size: 3)
+=>
+P(S+0 uint32, ret:eax uint32) Compound(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/ia32_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/ia32_win.expect
new file mode 100644
index 0000000..91c0595
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/ia32_win.expect
@@ -0,0 +1,12 @@
+S+4 Compound(size: 3)
+S+8 Compound(size: 3)
+S+12 Compound(size: 3)
+S+16 Compound(size: 3)
+S+20 Compound(size: 3)
+S+24 Compound(size: 3)
+S+28 Compound(size: 3)
+S+32 Compound(size: 3)
+S+36 Compound(size: 3)
+S+40 Compound(size: 3)
+=>
+P(S+0 uint32, ret:eax uint32) Compound(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_ios.expect
new file mode 100644
index 0000000..7f90b7a
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_ios.expect
@@ -0,0 +1,12 @@
+M(rdi int64) Compound(size: 3)
+M(rsi int64) Compound(size: 3)
+M(rdx int64) Compound(size: 3)
+M(rcx int64) Compound(size: 3)
+M(r8 int64) Compound(size: 3)
+M(r9 int64) Compound(size: 3)
+S+0 Compound(size: 3)
+S+8 Compound(size: 3)
+S+16 Compound(size: 3)
+S+24 Compound(size: 3)
+=>
+M(rax int64) Compound(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_linux.expect
new file mode 100644
index 0000000..7f90b7a
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_linux.expect
@@ -0,0 +1,12 @@
+M(rdi int64) Compound(size: 3)
+M(rsi int64) Compound(size: 3)
+M(rdx int64) Compound(size: 3)
+M(rcx int64) Compound(size: 3)
+M(r8 int64) Compound(size: 3)
+M(r9 int64) Compound(size: 3)
+S+0 Compound(size: 3)
+S+8 Compound(size: 3)
+S+16 Compound(size: 3)
+S+24 Compound(size: 3)
+=>
+M(rax int64) Compound(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_macos.expect
new file mode 100644
index 0000000..7f90b7a
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_macos.expect
@@ -0,0 +1,12 @@
+M(rdi int64) Compound(size: 3)
+M(rsi int64) Compound(size: 3)
+M(rdx int64) Compound(size: 3)
+M(rcx int64) Compound(size: 3)
+M(r8 int64) Compound(size: 3)
+M(r9 int64) Compound(size: 3)
+S+0 Compound(size: 3)
+S+8 Compound(size: 3)
+S+16 Compound(size: 3)
+S+24 Compound(size: 3)
+=>
+M(rax int64) Compound(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_win.expect
new file mode 100644
index 0000000..4b80330
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_win.expect
@@ -0,0 +1,12 @@
+P(rdx int64) Compound(size: 3)
+P(r8 int64) Compound(size: 3)
+P(r9 int64) Compound(size: 3)
+P(S+0 int64) Compound(size: 3)
+P(S+8 int64) Compound(size: 3)
+P(S+16 int64) Compound(size: 3)
+P(S+24 int64) Compound(size: 3)
+P(S+32 int64) Compound(size: 3)
+P(S+40 int64) Compound(size: 3)
+P(S+48 int64) Compound(size: 3)
+=>
+P(rcx int64, ret:rax int64) Compound(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_android.expect
new file mode 100644
index 0000000..aae2f45
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_android.expect
@@ -0,0 +1,3 @@
+M(r0 int64) Compound(size: 8)
+=>
+M(r0 int64) Compound(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_ios.expect
new file mode 100644
index 0000000..aae2f45
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_ios.expect
@@ -0,0 +1,3 @@
+M(r0 int64) Compound(size: 8)
+=>
+M(r0 int64) Compound(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_linux.expect
new file mode 100644
index 0000000..aae2f45
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_linux.expect
@@ -0,0 +1,3 @@
+M(r0 int64) Compound(size: 8)
+=>
+M(r0 int64) Compound(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_macos.expect
new file mode 100644
index 0000000..aae2f45
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_macos.expect
@@ -0,0 +1,3 @@
+M(r0 int64) Compound(size: 8)
+=>
+M(r0 int64) Compound(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_android.expect
new file mode 100644
index 0000000..0dac74d
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_android.expect
@@ -0,0 +1,3 @@
+M(r1 int32, r2 int32) Compound(size: 8)
+=>
+P(r0 uint32) Compound(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_ios.expect
new file mode 100644
index 0000000..0dac74d
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_ios.expect
@@ -0,0 +1,3 @@
+M(r1 int32, r2 int32) Compound(size: 8)
+=>
+P(r0 uint32) Compound(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_linux.expect
new file mode 100644
index 0000000..0dac74d
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_linux.expect
@@ -0,0 +1,3 @@
+M(r1 int32, r2 int32) Compound(size: 8)
+=>
+P(r0 uint32) Compound(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/ia32_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/ia32_android.expect
new file mode 100644
index 0000000..b6e748c
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/ia32_android.expect
@@ -0,0 +1,3 @@
+S+4 Compound(size: 8)
+=>
+P(S+0 uint32, ret:eax uint32) Compound(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/ia32_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/ia32_linux.expect
new file mode 100644
index 0000000..b6e748c
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/ia32_linux.expect
@@ -0,0 +1,3 @@
+S+4 Compound(size: 8)
+=>
+P(S+0 uint32, ret:eax uint32) Compound(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/ia32_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/ia32_win.expect
new file mode 100644
index 0000000..3778ea7
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/ia32_win.expect
@@ -0,0 +1,3 @@
+S+0 Compound(size: 8)
+=>
+M(eax uint32, edx uint32) Compound(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_ios.expect
new file mode 100644
index 0000000..80d98b3
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_ios.expect
@@ -0,0 +1,3 @@
+M(rdi int64) Compound(size: 8)
+=>
+M(rax int64) Compound(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_linux.expect
new file mode 100644
index 0000000..80d98b3
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_linux.expect
@@ -0,0 +1,3 @@
+M(rdi int64) Compound(size: 8)
+=>
+M(rax int64) Compound(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_macos.expect
new file mode 100644
index 0000000..80d98b3
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_macos.expect
@@ -0,0 +1,3 @@
+M(rdi int64) Compound(size: 8)
+=>
+M(rax int64) Compound(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_win.expect
new file mode 100644
index 0000000..5610272
--- /dev/null
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_win.expect
@@ -0,0 +1,3 @@
+M(rcx int64) Compound(size: 8)
+=>
+M(rax int64) Compound(size: 8)
diff --git a/runtime/vm/constants_arm.h b/runtime/vm/constants_arm.h
index 82a86da..5c2d42f 100644
--- a/runtime/vm/constants_arm.h
+++ b/runtime/vm/constants_arm.h
@@ -487,7 +487,7 @@
   static const intptr_t kArgumentRegisters = kAbiArgumentCpuRegs;
   static const Register ArgumentRegisters[];
   static const intptr_t kNumArgRegs = 4;
-  static const Register kPointerToReturnStructRegister = R0;
+  static const Register kPointerToReturnStructRegisterCall = R0;
 
   static const intptr_t kFpuArgumentRegisters = 0;
 
@@ -527,6 +527,7 @@
   static constexpr Register kReturnReg = R0;
   static constexpr Register kSecondReturnReg = R1;
   static constexpr FpuRegister kReturnFpuReg = Q0;
+  static constexpr Register kPointerToReturnStructRegisterReturn = kReturnReg;
 
   // We choose these to avoid overlap between themselves and reserved registers.
   static constexpr Register kFirstNonArgumentRegister = R8;
@@ -536,7 +537,7 @@
 
   COMPILE_ASSERT(
       ((R(kFirstNonArgumentRegister) | R(kSecondNonArgumentRegister)) &
-       (kArgumentRegisters | R(kPointerToReturnStructRegister))) == 0);
+       (kArgumentRegisters | R(kPointerToReturnStructRegisterCall))) == 0);
 };
 
 #undef R
diff --git a/runtime/vm/constants_arm64.h b/runtime/vm/constants_arm64.h
index da0e6d7..5e94310 100644
--- a/runtime/vm/constants_arm64.h
+++ b/runtime/vm/constants_arm64.h
@@ -346,7 +346,8 @@
   // The native ABI uses R8 to pass the pointer to the memory preallocated for
   // struct return values. Arm64 is the only ABI in which this pointer is _not_
   // in ArgumentRegisters[0] or on the stack.
-  static const Register kPointerToReturnStructRegister = R8;
+  static const Register kPointerToReturnStructRegisterCall = R8;
+  static const Register kPointerToReturnStructRegisterReturn = R8;
 
   static const FpuRegister FpuArgumentRegisters[];
   static const intptr_t kFpuArgumentRegisters =
@@ -363,6 +364,9 @@
 
   // How stack arguments are aligned.
 #if defined(TARGET_OS_MACOS_IOS)
+  // > Function arguments may consume slots on the stack that are not multiples
+  // > of 8 bytes.
+  // https://developer.apple.com/documentation/xcode/writing_arm64_code_for_apple_platforms
   static constexpr AlignmentStrategy kArgumentStackAlignment =
       kAlignedToValueSize;
 #else
@@ -395,7 +399,7 @@
 
   COMPILE_ASSERT(
       ((R(kFirstNonArgumentRegister) | R(kSecondNonArgumentRegister)) &
-       (kArgumentRegisters | R(kPointerToReturnStructRegister))) == 0);
+       (kArgumentRegisters | R(kPointerToReturnStructRegisterCall))) == 0);
 };
 
 #undef R
diff --git a/runtime/vm/constants_ia32.h b/runtime/vm/constants_ia32.h
index eba92da..8e47d4d 100644
--- a/runtime/vm/constants_ia32.h
+++ b/runtime/vm/constants_ia32.h
@@ -251,7 +251,7 @@
   static const intptr_t kArgumentRegisters = 0;
   static const intptr_t kFpuArgumentRegisters = 0;
   static const intptr_t kNumArgRegs = 0;
-  static const Register kPointerToReturnStructRegister = kNoRegister;
+  static const Register kPointerToReturnStructRegisterCall = kNoRegister;
 
   static const XmmRegister FpuArgumentRegisters[];
   static const intptr_t kXmmArgumentRegisters = 0;
@@ -264,6 +264,7 @@
 
   static constexpr Register kReturnReg = EAX;
   static constexpr Register kSecondReturnReg = EDX;
+  static constexpr Register kPointerToReturnStructRegisterReturn = kReturnReg;
 
   // Floating point values are returned on the "FPU stack" (in "ST" registers).
   // However, we use XMM0 in our compiler pipeline as the location.
diff --git a/runtime/vm/constants_x64.h b/runtime/vm/constants_x64.h
index e154cb2..824a871 100644
--- a/runtime/vm/constants_x64.h
+++ b/runtime/vm/constants_x64.h
@@ -309,12 +309,12 @@
   static const intptr_t kArgumentRegisters =
       R(kArg1Reg) | R(kArg2Reg) | R(kArg3Reg) | R(kArg4Reg);
   static const intptr_t kNumArgRegs = 4;
+  static const Register kPointerToReturnStructRegisterCall = kArg1Reg;
 
   static const XmmRegister FpuArgumentRegisters[];
   static const intptr_t kFpuArgumentRegisters =
       R(XMM0) | R(XMM1) | R(XMM2) | R(XMM3);
   static const intptr_t kNumFpuArgRegs = 4;
-  static const intptr_t kPointerToReturnStructRegister = kArg1Reg;
 
   // can ArgumentRegisters[i] and XmmArgumentRegisters[i] both be used at the
   // same time? (Windows no, rest yes)
@@ -354,6 +354,7 @@
   static constexpr Register kReturnReg = RAX;
   static constexpr Register kSecondReturnReg = kNoRegister;
   static constexpr FpuRegister kReturnFpuReg = XMM0;
+  static constexpr Register kPointerToReturnStructRegisterReturn = kReturnReg;
 
   // Whether larger than wordsize arguments are aligned to even registers.
   static constexpr AlignmentStrategy kArgumentRegisterAlignment =
@@ -384,7 +385,7 @@
                                              R(kArg3Reg) | R(kArg4Reg) |
                                              R(kArg5Reg) | R(kArg6Reg);
   static const intptr_t kNumArgRegs = 6;
-  static const Register kPointerToReturnStructRegister = kArg1Reg;
+  static const Register kPointerToReturnStructRegisterCall = kArg1Reg;
 
   static const XmmRegister FpuArgumentRegisters[];
   static const intptr_t kFpuArgumentRegisters = R(XMM0) | R(XMM1) | R(XMM2) |
@@ -415,8 +416,10 @@
   static const XmmRegister xmmFirstNonParameterReg = XMM8;
 
   static constexpr Register kReturnReg = RAX;
-  static constexpr Register kSecondReturnReg = kNoRegister;
+  static constexpr Register kSecondReturnReg = RDX;
   static constexpr FpuRegister kReturnFpuReg = XMM0;
+  static constexpr FpuRegister kSecondReturnFpuReg = XMM1;
+  static constexpr Register kPointerToReturnStructRegisterReturn = kReturnReg;
 
   // Whether larger than wordsize arguments are aligned to even registers.
   static constexpr AlignmentStrategy kArgumentRegisterAlignment =
@@ -451,7 +454,7 @@
 
   COMPILE_ASSERT(
       ((R(kFirstNonArgumentRegister) | R(kSecondNonArgumentRegister)) &
-       (kArgumentRegisters | R(kPointerToReturnStructRegister))) == 0);
+       (kArgumentRegisters | R(kPointerToReturnStructRegisterCall))) == 0);
 };
 
 #undef R
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 83e255f..2e907af 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -24247,6 +24247,8 @@
   // for each frame.
   intptr_t frame_index = 0;
   uint32_t frame_skip = 0;
+  // If we're already in a gap, don't print multiple gap markers.
+  bool in_gap = false;
   do {
     for (intptr_t i = frame_skip; i < stack_trace.Length(); i++) {
       code_object = stack_trace.CodeAtFrame(i);
@@ -24260,72 +24262,87 @@
           // To account for gap frames.
           frame_index += Smi::Value(stack_trace.PcOffsetAtFrame(i));
         }
-      } else if (code_object.raw() == StubCode::AsynchronousGapMarker().raw()) {
-        buffer.AddString("<asynchronous suspension>\n");
-      } else {
-        intptr_t pc_offset = Smi::Value(stack_trace.PcOffsetAtFrame(i));
-        ASSERT(code_object.IsCode());
-        code ^= code_object.raw();
-        ASSERT(code.IsFunctionCode());
-        function = code.function();
-        const uword pc = code.PayloadStart() + pc_offset;
-#if defined(DART_PRECOMPILED_RUNTIME)
-        // When printing non-symbolic frames, we normally print call
-        // addresses, not return addresses, by subtracting one from the PC to
-        // get an address within the preceding instruction.
-        //
-        // The one exception is a normal closure registered as a listener on a
-        // future. In this case, the returned pc_offset is 0, as the closure
-        // is invoked with the value of the resolved future. Thus, we must
-        // report the return address, as returning a value before the closure
-        // payload will cause failures to decode the frame using DWARF info.
-        const bool is_future_listener = pc_offset == 0;
-        const uword call_addr = is_future_listener ? pc : pc - 1;
-        if (FLAG_dwarf_stack_traces_mode) {
-          // If we have access to the owning function and it would be
-          // invisible in a symbolic stack trace, don't show this frame.
-          // (We can't do the same for inlined functions, though.)
-          if (!FLAG_show_invisible_frames && !function.IsNull() &&
-              !function.is_visible()) {
-            continue;
-          }
-          // This output is formatted like Android's debuggerd. Note debuggerd
-          // prints call addresses instead of return addresses.
-          buffer.Printf("    #%02" Pd " abs %" Pp "", frame_index, call_addr);
-          PrintNonSymbolicStackFrameBody(&buffer, call_addr,
-                                         isolate_instructions, vm_instructions);
-          frame_index++;
-          continue;
-        } else if (function.IsNull()) {
-          // We can't print the symbolic information since the owner was not
-          // retained, so instead print the static symbol + offset like the
-          // non-symbolic stack traces.
-          PrintSymbolicStackFrameIndex(&buffer, frame_index);
-          PrintNonSymbolicStackFrameBody(&buffer, call_addr,
-                                         isolate_instructions, vm_instructions);
-          frame_index++;
-          continue;
-        }
-#endif
-        if (code.is_optimized() && stack_trace.expand_inlined()) {
-          code.GetInlinedFunctionsAtReturnAddress(pc_offset, &inlined_functions,
-                                                  &inlined_token_positions);
-          ASSERT(inlined_functions.length() >= 1);
-          for (intptr_t j = inlined_functions.length() - 1; j >= 0; j--) {
-            const auto& inlined = *inlined_functions[j];
-            auto const pos = inlined_token_positions[j];
-            if (FLAG_show_invisible_frames || function.is_visible()) {
-              PrintSymbolicStackFrame(zone, &buffer, inlined, pos, frame_index);
-              frame_index++;
-            }
-          }
-        } else if (FLAG_show_invisible_frames || function.is_visible()) {
-          auto const pos = code.GetTokenIndexOfPC(pc);
-          PrintSymbolicStackFrame(zone, &buffer, function, pos, frame_index);
-          frame_index++;
-        }
+        continue;
       }
+
+      if (code_object.raw() == StubCode::AsynchronousGapMarker().raw()) {
+        if (!in_gap) {
+          buffer.AddString("<asynchronous suspension>\n");
+        }
+        in_gap = true;
+        continue;
+      }
+
+      intptr_t pc_offset = Smi::Value(stack_trace.PcOffsetAtFrame(i));
+      ASSERT(code_object.IsCode());
+      code ^= code_object.raw();
+      ASSERT(code.IsFunctionCode());
+      function = code.function();
+      const uword pc = code.PayloadStart() + pc_offset;
+
+      // If the function is not to be shown, skip.
+      if (!FLAG_show_invisible_frames && !function.IsNull() &&
+          !function.is_visible()) {
+        continue;
+      }
+
+      // A visible frame ends any gap we might be in.
+      in_gap = false;
+
+#if defined(DART_PRECOMPILED_RUNTIME)
+      // When printing non-symbolic frames, we normally print call
+      // addresses, not return addresses, by subtracting one from the PC to
+      // get an address within the preceding instruction.
+      //
+      // The one exception is a normal closure registered as a listener on a
+      // future. In this case, the returned pc_offset is 0, as the closure
+      // is invoked with the value of the resolved future. Thus, we must
+      // report the return address, as returning a value before the closure
+      // payload will cause failures to decode the frame using DWARF info.
+      const bool is_future_listener = pc_offset == 0;
+      const uword call_addr = is_future_listener ? pc : pc - 1;
+
+      if (FLAG_dwarf_stack_traces_mode) {
+        // This output is formatted like Android's debuggerd. Note debuggerd
+        // prints call addresses instead of return addresses.
+        buffer.Printf("    #%02" Pd " abs %" Pp "", frame_index, call_addr);
+        PrintNonSymbolicStackFrameBody(&buffer, call_addr, isolate_instructions,
+                                       vm_instructions);
+        frame_index++;
+        continue;
+      }
+
+      if (function.IsNull()) {
+        in_gap = false;
+        // We can't print the symbolic information since the owner was not
+        // retained, so instead print the static symbol + offset like the
+        // non-symbolic stack traces.
+        PrintSymbolicStackFrameIndex(&buffer, frame_index);
+        PrintNonSymbolicStackFrameBody(&buffer, call_addr, isolate_instructions,
+                                       vm_instructions);
+        frame_index++;
+        continue;
+      }
+#endif
+
+      if (code.is_optimized() && stack_trace.expand_inlined()) {
+        code.GetInlinedFunctionsAtReturnAddress(pc_offset, &inlined_functions,
+                                                &inlined_token_positions);
+        ASSERT(inlined_functions.length() >= 1);
+        for (intptr_t j = inlined_functions.length() - 1; j >= 0; j--) {
+          const auto& inlined = *inlined_functions[j];
+          auto const pos = inlined_token_positions[j];
+          PrintSymbolicStackFrame(zone, &buffer, inlined, pos, frame_index);
+          frame_index++;
+        }
+        continue;
+      }
+
+      auto const pos = code.GetTokenIndexOfPC(pc);
+      PrintSymbolicStackFrame(zone, &buffer, function, pos, frame_index);
+      frame_index++;
     }
+
     // Follow the link.
     frame_skip = stack_trace.skip_sync_start_in_parent_stack()
                      ? StackTrace::kSyncAsyncCroppedFrames
diff --git a/tools/VERSION b/tools/VERSION
index 82152ac..69c5f6b 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 12
 PATCH 0
-PRERELEASE 61
+PRERELEASE 62
 PRERELEASE_PATCH 0
\ No newline at end of file