diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index c20f7d6..0eb702a 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -1650,8 +1650,17 @@
   /// of this variable could not be computed because of errors.
   DartObject? computeConstantValue() {
     if (evaluationResult == null) {
-      computeConstants(library!.typeProvider, library!.typeSystem,
-          context.declaredVariables, [this], library!.featureSet);
+      final library = this.library;
+      // TODO(scheglov) https://github.com/dart-lang/sdk/issues/47915
+      if (library == null) {
+        throw StateError(
+          '[library: null][this: ($runtimeType) $this]'
+          '[enclosingElement: $enclosingElement]'
+          '[reference: $reference]',
+        );
+      }
+      computeConstants(library.typeProvider, library.typeSystem,
+          context.declaredVariables, [this], library.featureSet);
     }
     return evaluationResult?.value;
   }
diff --git a/pkg/analyzer/test/generated/element_resolver_test.dart b/pkg/analyzer/test/generated/element_resolver_test.dart
index a018a3e..745bc51 100644
--- a/pkg/analyzer/test/generated/element_resolver_test.dart
+++ b/pkg/analyzer/test/generated/element_resolver_test.dart
@@ -14,7 +14,6 @@
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/inheritance_manager3.dart';
 import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
-import 'package:analyzer/src/generated/element_resolver.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
@@ -275,12 +274,12 @@
   /// The library containing the code being resolved.
   late LibraryElementImpl _definingLibrary;
 
+  /// The compilation unit containing the code being resolved.
+  late CompilationUnitElementImpl _definingCompilationUnit;
+
   /// The resolver visitor that maintains the state for the resolver.
   late ResolverVisitor _visitor;
 
-  /// The resolver being used to resolve the test cases.
-  late ElementResolver _resolver;
-
   @override
   TypeProvider get typeProvider => _typeProvider;
 
@@ -568,6 +567,7 @@
 
   test_visitInstanceCreationExpression_named() async {
     ClassElementImpl classA = ElementFactory.classElement2("A");
+    _definingCompilationUnit.classes = [classA];
     String constructorName = "a";
     ConstructorElement constructor =
         ElementFactory.constructorElement2(classA, constructorName);
@@ -583,6 +583,7 @@
 
   test_visitInstanceCreationExpression_unnamed() async {
     ClassElementImpl classA = ElementFactory.classElement2("A");
+    _definingCompilationUnit.classes = [classA];
     String constructorName = 'named';
     ConstructorElement constructor =
         ElementFactory.constructorElement2(classA, constructorName);
@@ -598,6 +599,7 @@
 
   test_visitInstanceCreationExpression_unnamed_namedParameter() async {
     ClassElementImpl classA = ElementFactory.classElement2("A");
+    _definingCompilationUnit.classes = [classA];
     String constructorName = 'named';
     ConstructorElementImpl constructor =
         ElementFactory.constructorElement2(classA, constructorName);
@@ -625,8 +627,10 @@
 
   test_visitMethodInvocation() async {
     InterfaceType numType = _typeProvider.numType;
-    var left = AstTestFactory.identifier3("i");
-    left.staticType = numType;
+    var iGetter = ElementFactory.getterElement('i', true, numType);
+    _definingCompilationUnit.accessors = [iGetter];
+    var left = AstTestFactory.identifier3("i")
+      ..scopeLookupResult = ScopeLookupResult(iGetter, null);
     String methodName = "abs";
     MethodInvocation invocation =
         AstTestFactory.methodInvocation(left, methodName);
@@ -669,6 +673,7 @@
       AstTestFactory.constructorDeclaration(AstTestFactory.identifier3('C'),
           null, AstTestFactory.formalParameterList(), [invocation])
     ]);
+    _definingCompilationUnit.classes = [superclass, subclass];
     _resolveInClass(invocation, subclass);
     expect(invocation.staticElement, superConstructor);
     _listener.assertNoErrors();
@@ -680,7 +685,8 @@
     ConstructorElementImpl superConstructor =
         ElementFactory.constructorElement2(superclass, null);
     String parameterName = "p";
-    ParameterElement parameter = ElementFactory.namedParameter(parameterName);
+    ParameterElement parameter = ElementFactory.namedParameter(parameterName)
+      ..type = _typeProvider.dynamicType;
     superConstructor.parameters = <ParameterElement>[parameter];
     superclass.constructors = <ConstructorElement>[superConstructor];
     ClassElementImpl subclass =
@@ -697,6 +703,7 @@
       AstTestFactory.constructorDeclaration(AstTestFactory.identifier3('C'),
           null, AstTestFactory.formalParameterList(), [invocation])
     ]);
+    _definingCompilationUnit.classes = [superclass, subclass];
     _resolveInClass(invocation, subclass);
     expect(invocation.staticElement, superConstructor);
     expect(
@@ -714,10 +721,11 @@
     _typeProvider = context.typeProviderLegacy;
 
     Source source = FileSource(getFile("/test.dart"));
-    CompilationUnitElementImpl unit = CompilationUnitElementImpl();
-    unit.librarySource = unit.source = source;
+    _definingCompilationUnit = CompilationUnitElementImpl();
+    _definingCompilationUnit.librarySource =
+        _definingCompilationUnit.source = source;
     _definingLibrary = ElementFactory.library(context, "test");
-    _definingLibrary.definingCompilationUnit = unit;
+    _definingLibrary.definingCompilationUnit = _definingCompilationUnit;
 
     _definingLibrary.typeProvider = context.typeProviderLegacy;
     _definingLibrary.typeSystem = context.typeSystemLegacy;
@@ -729,7 +737,6 @@
         featureSet: featureSet,
         flowAnalysisHelper:
             FlowAnalysisHelper(context.typeSystemLegacy, false, featureSet));
-    _resolver = _visitor.elementResolver;
   }
 
   void _encloseElement(ElementImpl element) {
@@ -773,7 +780,7 @@
   void _resolveInClass(AstNode node, ClassElement enclosingClass) {
     try {
       _visitor.enclosingClass = enclosingClass;
-      node.accept(_resolver);
+      node.accept(_visitor);
     } finally {
       _visitor.enclosingClass = null;
     }
@@ -787,7 +794,7 @@
   ///          which the element is being resolved
   /// @return the element to which the expression was resolved
   void _resolveNode(AstNode node) {
-    node.accept(_resolver);
+    node.accept(_visitor);
   }
 
   /// Return the element associated with the label of the given statement after
@@ -799,7 +806,7 @@
   /// @return the element to which the statement's label was resolved
   void _resolveStatement(Statement statement, LabelElementImpl? labelElement,
       AstNode? labelTarget) {
-    statement.accept(_resolver);
+    statement.accept(_visitor);
   }
 }
 
diff --git a/pkg/analyzer/test/generated/static_type_analyzer_test.dart b/pkg/analyzer/test/generated/static_type_analyzer_test.dart
index 6d3741a..145865a 100644
--- a/pkg/analyzer/test/generated/static_type_analyzer_test.dart
+++ b/pkg/analyzer/test/generated/static_type_analyzer_test.dart
@@ -5,7 +5,9 @@
 import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/analysis/session.dart';
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/scope.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/element/type_provider.dart';
 import 'package:analyzer/src/dart/ast/extensions.dart';
@@ -16,7 +18,6 @@
 import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
 import 'package:analyzer/src/generated/resolver.dart' show ResolverVisitor;
 import 'package:analyzer/src/generated/source.dart';
-import 'package:analyzer/src/generated/static_type_analyzer.dart';
 import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/source/source_resource.dart';
@@ -54,8 +55,8 @@
   /// The library containing the code being resolved.
   late final LibraryElementImpl _definingLibrary;
 
-  /// The analyzer being used to analyze the test cases.
-  late final StaticTypeAnalyzer _analyzer;
+  /// The compilation unit containing the code being resolved.
+  late CompilationUnitElementImpl _definingCompilationUnit;
 
   /// The type provider used to access the types.
   late final TypeProvider _typeProvider;
@@ -272,8 +273,9 @@
 
   void test_visitCascadeExpression() {
     // a..length
-    Expression node = AstTestFactory.cascadeExpression(
-        _resolvedString("a"), [AstTestFactory.propertyAccess2(null, "length")]);
+    Expression node = AstTestFactory.cascadeExpression(_resolvedString("a"), [
+      AstTestFactory.propertyAccess2(null, "length", TokenType.PERIOD_PERIOD)
+    ]);
     expect(_analyze(node), same(_typeProvider.stringType));
     _listener.assertNoErrors();
   }
@@ -308,15 +310,17 @@
   void test_visitInstanceCreationExpression_named() {
     // new C.m()
     ClassElementImpl classElement = ElementFactory.classElement2("C");
+    _definingCompilationUnit.classes = [classElement];
     String constructorName = "m";
     ConstructorElementImpl constructor =
         ElementFactory.constructorElement2(classElement, constructorName);
     classElement.constructors = <ConstructorElement>[constructor];
     InstanceCreationExpression node =
         AstTestFactory.instanceCreationExpression2(
-            null,
-            AstTestFactory.namedType(classElement),
-            [AstTestFactory.identifier3(constructorName)]);
+            null, AstTestFactory.namedType(classElement), [
+      AstTestFactory.identifier3(constructorName)
+        ..scopeLookupResult = ScopeLookupResult(constructor, null)
+    ]);
     expect(_analyze(node), interfaceTypeStar(classElement));
     _listener.assertNoErrors();
   }
@@ -334,6 +338,7 @@
         typeArguments: [interfaceTypeStar(elementI)]);
     InstanceCreationExpression node =
         AstTestFactory.instanceCreationExpression2(null, typeName);
+    _definingCompilationUnit.classes = [elementC, elementI];
     InterfaceType type = _analyze(node) as InterfaceType;
     List<DartType> typeArgs = type.typeArguments;
     expect(typeArgs.length, 1);
@@ -344,6 +349,7 @@
   void test_visitInstanceCreationExpression_unnamed() {
     // new C()
     ClassElementImpl classElement = ElementFactory.classElement2("C");
+    _definingCompilationUnit.classes = [classElement];
     ConstructorElementImpl constructor =
         ElementFactory.constructorElement2(classElement, null);
     classElement.constructors = <ConstructorElement>[constructor];
@@ -434,6 +440,13 @@
     InterfaceType thisType =
         interfaceTypeStar(ElementFactory.classElement("B", superType));
     Expression node = AstTestFactory.superExpression();
+    // Place the super expression inside a method declaration
+    // (`test() => super.foo;`) so that we don't provoke a
+    // SUPER_IN_INVALID_CONTEXT error
+    AstTestFactory.methodDeclaration4(
+        name: 'test',
+        body: AstTestFactory.expressionFunctionBody(
+            AstTestFactory.propertyAccess2(node, 'foo')));
     expect(_analyze(node, thisType), same(thisType));
     _listener.assertNoErrors();
   }
@@ -466,7 +479,7 @@
     if (thisType != null) {
       _visitor.setThisInterfaceType(thisType);
     }
-    node.accept(_analyzer);
+    node.accept(_visitor);
     return node.typeOrThrow;
   }
 
@@ -499,15 +512,14 @@
     var context = TestAnalysisContext();
     var inheritance = InheritanceManager3();
     Source source = FileSource(getFile("/lib.dart"));
-    CompilationUnitElementImpl definingCompilationUnit =
-        CompilationUnitElementImpl();
-    definingCompilationUnit.librarySource =
-        definingCompilationUnit.source = source;
+    _definingCompilationUnit = CompilationUnitElementImpl();
+    _definingCompilationUnit.librarySource =
+        _definingCompilationUnit.source = source;
     var featureSet = FeatureSet.latestLanguageVersion();
 
     _definingLibrary = LibraryElementImpl(
         context, _AnalysisSessionMock(), 'name', -1, 0, featureSet);
-    _definingLibrary.definingCompilationUnit = definingCompilationUnit;
+    _definingLibrary.definingCompilationUnit = _definingCompilationUnit;
 
     _definingLibrary.typeProvider = context.typeProviderLegacy;
     _definingLibrary.typeSystem = context.typeSystemLegacy;
@@ -518,7 +530,6 @@
         featureSet: featureSet,
         flowAnalysisHelper:
             FlowAnalysisHelper(context.typeSystemLegacy, false, featureSet));
-    _analyzer = _visitor.typeAnalyzer;
   }
 
   DartType _flatten(DartType type) => _typeSystem.flatten(type);
diff --git a/pkg/analyzer_utilities/lib/check/check.dart b/pkg/analyzer_utilities/lib/check/check.dart
index b3147bb..54b57c9 100644
--- a/pkg/analyzer_utilities/lib/check/check.dart
+++ b/pkg/analyzer_utilities/lib/check/check.dart
@@ -10,6 +10,7 @@
 export 'package:analyzer_utilities/check/equality.dart';
 export 'package:analyzer_utilities/check/int.dart';
 export 'package:analyzer_utilities/check/iterable.dart';
+export 'package:analyzer_utilities/check/nullability.dart';
 export 'package:analyzer_utilities/check/string.dart';
 export 'package:analyzer_utilities/check/type.dart';
 
diff --git a/pkg/analyzer_utilities/lib/check/check_target.dart b/pkg/analyzer_utilities/lib/check/check_target.dart
index 1d0e608..d22a1ac 100644
--- a/pkg/analyzer_utilities/lib/check/check_target.dart
+++ b/pkg/analyzer_utilities/lib/check/check_target.dart
@@ -16,13 +16,6 @@
 
   String get _indent => '  ' * (_depth + 1);
 
-  String valueStr(value) {
-    if (value is String) {
-      return "'$value'";
-    }
-    return '$value';
-  }
-
   Never fail(String message) {
     test_package.fail(_describe() + '\n' + _indent + message);
   }
@@ -37,4 +30,16 @@
       return _describe() + '\n' + _indent + describe(value);
     });
   }
+
+  String valueStr(value) {
+    if (value is String) {
+      return "'$value'";
+    }
+    return '$value';
+  }
+
+  /// Use this if multiple checks are required on the value.
+  void which(void Function(CheckTarget<T> e) checker) {
+    checker(this);
+  }
 }
diff --git a/pkg/analyzer_utilities/lib/check/nullability.dart b/pkg/analyzer_utilities/lib/check/nullability.dart
new file mode 100644
index 0000000..3a31513
--- /dev/null
+++ b/pkg/analyzer_utilities/lib/check/nullability.dart
@@ -0,0 +1,21 @@
+// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer_utilities/check/check.dart';
+
+extension NullabilityExtension<T> on CheckTarget<T?> {
+  void get isNull {
+    if (value != null) {
+      fail('is not null');
+    }
+  }
+
+  CheckTarget<T> get isNotNull {
+    final value = this.value;
+    if (value == null) {
+      fail('is null');
+    }
+    return nest(value, (value) => 'is not null');
+  }
+}
diff --git a/pkg/analyzer_utilities/test/check/check_test.dart b/pkg/analyzer_utilities/test/check/check_test.dart
index cc52f80..907438f 100644
--- a/pkg/analyzer_utilities/test/check/check_test.dart
+++ b/pkg/analyzer_utilities/test/check/check_test.dart
@@ -97,6 +97,18 @@
         _fails(() => check(<int>{}).isNotEmpty);
       });
     });
+    group('nullability', () {
+      const int? notNullable = 0;
+      const int? nullable = null;
+      test('isNotNull', () {
+        check(notNullable).isNotNull;
+        _fails(() => check(nullable).isNotNull.isZero);
+      });
+      test('isNull', () {
+        check(nullable).isNull;
+        _fails(() => check(notNullable).isNull);
+      });
+    });
     group('String', () {
       test('contains', () {
         check('abc').contains('a');
@@ -153,6 +165,10 @@
         _fails(() => check('abc' as dynamic).isA<int>());
       });
     });
+    test('which', () {
+      check(0).which((e) => e.isZero);
+      _fails(() => check(1).which((e) => e.isZero));
+    });
   });
 }
 
diff --git a/pkg/compiler/lib/src/compiler.dart b/pkg/compiler/lib/src/compiler.dart
index 5fe0521..dad3d720 100644
--- a/pkg/compiler/lib/src/compiler.dart
+++ b/pkg/compiler/lib/src/compiler.dart
@@ -354,7 +354,7 @@
             dumpUnusedLibraries(result);
           }
           if (options.entryUri != null) {
-            result.trimComponent(options.entryUri);
+            result.trimComponent();
           }
         }
         if (options.cfeOnly) {
diff --git a/pkg/compiler/lib/src/kernel/loader.dart b/pkg/compiler/lib/src/kernel/loader.dart
index e671f3e..cdab490 100644
--- a/pkg/compiler/lib/src/kernel/loader.dart
+++ b/pkg/compiler/lib/src/kernel/loader.dart
@@ -96,6 +96,9 @@
         return "${targetName}_platform$unsoundMarker.dill";
       }
 
+      // If we are passed an [entryUri] and building from dill, then we lookup
+      // the [entryLibrary] in the built component.
+      Library entryLibrary;
       var resolvedUri = _options.compilationTarget;
       ir.Component component;
       List<Uri> moduleLibraries = const [];
@@ -161,16 +164,10 @@
         }
 
         if (_options.entryUri != null) {
-          var entryLibrary = _findEntryLibrary(component, _options.entryUri);
+          entryLibrary = _findEntryLibrary(component, _options.entryUri);
           var mainMethod = _findMainMethod(entryLibrary);
           component.setMainMethodAndMode(mainMethod, true, component.mode);
         }
-        if (!_options.modularMode && component.mainMethod == null) {
-          // TODO(sigmund): move this so that we use the same error template
-          // from the CFE.
-          _reporter.reportError(_reporter.createMessage(NO_LOCATION_SPANNABLE,
-              MessageKind.GENERIC, {'text': "No 'main' method found."}));
-        }
       } else {
         bool verbose = false;
         Target target =
@@ -229,15 +226,31 @@
         component = ir.Component();
         BinaryBuilder(data).readComponent(component);
       }
-      return _toResult(component, moduleLibraries);
+      return _toResult(entryLibrary, component, moduleLibraries);
     });
   }
 
-  KernelResult _toResult(ir.Component component, List<Uri> moduleLibraries) {
+  KernelResult _toResult(
+      Library entryLibrary, ir.Component component, List<Uri> moduleLibraries) {
     Uri rootLibraryUri = null;
     Iterable<ir.Library> libraries = component.libraries;
-    if (!_options.modularMode && component.mainMethod != null) {
-      var root = component.mainMethod.enclosingLibrary;
+    if (!_options.modularMode) {
+      // For non-modular builds we should always have a [mainMethod] at this
+      // point.
+      if (component.mainMethod == null) {
+        // TODO(sigmund): move this so that we use the same error template
+        // from the CFE.
+        _reporter.reportError(_reporter.createMessage(NO_LOCATION_SPANNABLE,
+            MessageKind.GENERIC, {'text': "No 'main' method found."}));
+      }
+
+      // If we are building from dill and are passed an [entryUri], then we use
+      // that to find the appropriate [entryLibrary]. Otherwise, we fallback to
+      // the [enclosingLibrary] of the [mainMethod].
+      // NOTE: Under some circumstances, the [entryLibrary] exports the
+      // [mainMethod] from another library, and thus the [enclosingLibrary] of
+      // the [mainMethod] may not be the same as the [entryLibrary].
+      var root = entryLibrary ?? component.mainMethod.enclosingLibrary;
       rootLibraryUri = root.importUri;
 
       // Filter unreachable libraries: [Component] was built by linking in the
@@ -293,7 +306,7 @@
   KernelResult(this.component, this.rootLibraryUri, this.libraries,
       this.moduleLibraries);
 
-  void trimComponent(Uri entryUri) {
+  void trimComponent() {
     var irLibraryMap = <Uri, Library>{};
     var irLibraries = <Library>[];
     for (var library in component.libraries) {
diff --git a/pkg/front_end/lib/src/fasta/builder/procedure_builder.dart b/pkg/front_end/lib/src/fasta/builder/procedure_builder.dart
index 9439453..f09dc0d 100644
--- a/pkg/front_end/lib/src/fasta/builder/procedure_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/procedure_builder.dart
@@ -224,6 +224,7 @@
         return procedure;
       case ProcedureKind.Operator:
       case ProcedureKind.Setter:
+        return null;
     }
   }
 
diff --git a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
index e7890ff..44ee19e 100644
--- a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
@@ -1049,78 +1049,6 @@
       ];
     }
 
-    if (libraryBuilder.enableSuperParametersInLibrary) {
-      if (initializers.isNotEmpty && initializers.last is SuperInitializer) {
-        SuperInitializer superInitializer =
-            initializers.last as SuperInitializer;
-        Arguments arguments = superInitializer.arguments;
-
-        List<VariableDeclaration>? positionalSuperParameters;
-        List<VariableDeclaration>? namedSuperParameters;
-
-        List<FormalParameterBuilder>? formals =
-            (member as ConstructorBuilder).formals;
-        if (formals != null) {
-          for (FormalParameterBuilder formal in formals) {
-            if (formal.isSuperInitializingFormal) {
-              if (formal.isNamed) {
-                (namedSuperParameters ??= <VariableDeclaration>[])
-                    .add(formal.variable!);
-              } else {
-                (positionalSuperParameters ??= <VariableDeclaration>[])
-                    .add(formal.variable!);
-              }
-            }
-          }
-
-          if (positionalSuperParameters != null) {
-            if (arguments.positional.isNotEmpty) {
-              addProblem(fasta.messagePositionalSuperParametersAndArguments,
-                  arguments.fileOffset, noLength,
-                  context: <LocatedMessage>[
-                    fasta.messageSuperInitializerParameter.withLocation(uri,
-                        positionalSuperParameters.first.fileOffset, noLength)
-                  ]);
-            } else {
-              for (VariableDeclaration positional
-                  in positionalSuperParameters) {
-                arguments.positional.add(
-                    new VariableGetImpl(positional, forNullGuardedAccess: false)
-                      ..fileOffset = positional.fileOffset);
-              }
-            }
-          }
-          if (namedSuperParameters != null) {
-            // TODO(cstefantsova): Report name conflicts.
-            for (VariableDeclaration named in namedSuperParameters) {
-              arguments.named.add(new NamedExpression(
-                  named.name!,
-                  new VariableGetImpl(named, forNullGuardedAccess: false)
-                    ..fileOffset = named.fileOffset)
-                ..fileOffset = named.fileOffset);
-            }
-          }
-        }
-
-        LocatedMessage? message = checkArgumentsForFunction(
-            superInitializer.target.function,
-            arguments,
-            arguments.fileOffset, <TypeParameter>[]);
-        if (message != null) {
-          initializers[initializers.length - 1] = buildInvalidInitializer(
-              buildUnresolvedError(
-                  forest.createNullLiteral(superInitializer.fileOffset),
-                  constructorNameForDiagnostics(
-                      superInitializer.target.name.text),
-                  arguments,
-                  superInitializer.fileOffset,
-                  isSuper: true,
-                  message: message,
-                  kind: UnresolvedKind.Constructor));
-        }
-      }
-    }
-
     _initializers ??= <Initializer>[];
     _initializers!.addAll(initializers);
   }
@@ -1748,15 +1676,87 @@
         typeInferrer.flowAnalysis.declare(parameter.variable!, true);
       }
     }
-    if (_initializers != null) {
+
+    List<Expression>? positionalSuperParametersAsArguments;
+    List<NamedExpression>? namedSuperParametersAsArguments;
+    if (formals != null) {
+      for (FormalParameterBuilder formal in formals) {
+        if (formal.isSuperInitializingFormal) {
+          if (formal.isNamed) {
+            (namedSuperParametersAsArguments ??= <NamedExpression>[]).add(
+                new NamedExpression(
+                    formal.name,
+                    new VariableGetImpl(formal.variable!,
+                        forNullGuardedAccess: false)
+                      ..fileOffset = formal.charOffset)
+                  ..fileOffset = formal.charOffset);
+          } else {
+            (positionalSuperParametersAsArguments ??= <Expression>[]).add(
+                new VariableGetImpl(formal.variable!,
+                    forNullGuardedAccess: false)
+                  ..fileOffset = formal.charOffset);
+          }
+        }
+      }
+    }
+
+    List<Initializer>? initializers = _initializers;
+    if (initializers != null) {
+      if (libraryBuilder.enableSuperParametersInLibrary) {
+        if (initializers.isNotEmpty && initializers.last is SuperInitializer) {
+          SuperInitializer superInitializer =
+              initializers.last as SuperInitializer;
+          Arguments arguments = superInitializer.arguments;
+
+          if (positionalSuperParametersAsArguments != null) {
+            if (arguments.positional.isNotEmpty) {
+              addProblem(fasta.messagePositionalSuperParametersAndArguments,
+                  arguments.fileOffset, noLength,
+                  context: <LocatedMessage>[
+                    fasta.messageSuperInitializerParameter.withLocation(
+                        uri,
+                        (positionalSuperParametersAsArguments.first
+                                as VariableGet)
+                            .variable
+                            .fileOffset,
+                        noLength)
+                  ]);
+            } else {
+              arguments.positional.addAll(positionalSuperParametersAsArguments);
+            }
+          }
+          if (namedSuperParametersAsArguments != null) {
+            // TODO(cstefantsova): Report name conflicts.
+            arguments.named.addAll(namedSuperParametersAsArguments);
+          }
+
+          LocatedMessage? message = checkArgumentsForFunction(
+              superInitializer.target.function,
+              arguments,
+              arguments.fileOffset, <TypeParameter>[]);
+          if (message != null) {
+            initializers[initializers.length - 1] = buildInvalidInitializer(
+                buildUnresolvedError(
+                    forest.createNullLiteral(superInitializer.fileOffset),
+                    constructorNameForDiagnostics(
+                        superInitializer.target.name.text),
+                    arguments,
+                    superInitializer.fileOffset,
+                    isSuper: true,
+                    message: message,
+                    kind: UnresolvedKind.Constructor));
+          }
+        }
+      }
+
       Map<Initializer, InitializerInferenceResult> inferenceResults =
           <Initializer, InitializerInferenceResult>{};
-      for (Initializer initializer in _initializers!) {
+      for (Initializer initializer in initializers) {
         inferenceResults[initializer] =
             typeInferrer.inferInitializer(this, initializer);
       }
       if (!builder.isExternal) {
-        for (Initializer initializer in _initializers!) {
+        for (Initializer initializer in initializers) {
           builder.addInitializer(initializer, this,
               inferenceResult: inferenceResults[initializer]!);
         }
@@ -1772,7 +1772,14 @@
       /// >unless the enclosing class is class Object.
       Constructor? superTarget = lookupConstructor(emptyName, isSuper: true);
       Initializer initializer;
-      Arguments arguments = forest.createArgumentsEmpty(noLocation);
+      Arguments arguments;
+      if (libraryBuilder.enableSuperParametersInLibrary) {
+        arguments = forest.createArguments(
+            noLocation, positionalSuperParametersAsArguments ?? <Expression>[],
+            named: namedSuperParametersAsArguments);
+      } else {
+        arguments = forest.createArgumentsEmpty(noLocation);
+      }
       if (superTarget == null ||
           checkArgumentsForFunction(superTarget.function, arguments,
                   builder.charOffset, const <TypeParameter>[]) !=
diff --git a/pkg/front_end/lib/src/fasta/util/outline_extractor.dart b/pkg/front_end/lib/src/fasta/util/outline_extractor.dart
index 8caa3f6..ff65e37 100644
--- a/pkg/front_end/lib/src/fasta/util/outline_extractor.dart
+++ b/pkg/front_end/lib/src/fasta/util/outline_extractor.dart
@@ -527,6 +527,7 @@
         }
       }
     }
+    return null;
   }
 }
 
diff --git a/pkg/front_end/lib/src/fasta/util/parser_ast.dart b/pkg/front_end/lib/src/fasta/util/parser_ast.dart
index b648bfc..3b131cf 100644
--- a/pkg/front_end/lib/src/fasta/util/parser_ast.dart
+++ b/pkg/front_end/lib/src/fasta/util/parser_ast.dart
@@ -1137,6 +1137,7 @@
         }
       }
     }
+    return null;
   }
 
   String getImportUriString() {
diff --git a/pkg/front_end/testcases/super_parameters/simple.dart.strong.expect b/pkg/front_end/testcases/super_parameters/simple.dart.strong.expect
index a1ba70a..2738e5e 100644
--- a/pkg/front_end/testcases/super_parameters/simple.dart.strong.expect
+++ b/pkg/front_end/testcases/super_parameters/simple.dart.strong.expect
@@ -1,11 +1,4 @@
 library /*isNonNullableByDefault*/;
-//
-// Problems in library:
-//
-// pkg/front_end/testcases/super_parameters/simple.dart:11:3: Error: The superclass, 'A', has no unnamed constructor that takes no arguments.
-//   B(super.foo);
-//   ^
-//
 import self as self;
 import "dart:core" as core;
 
@@ -17,9 +10,7 @@
 }
 class B extends self::A {
   constructor •(dynamic foo) → self::B
-    : final dynamic #t1 = invalid-expression "pkg/front_end/testcases/super_parameters/simple.dart:11:3: Error: The superclass, 'A', has no unnamed constructor that takes no arguments.
-  B(super.foo);
-  ^"
+    : super self::A::•(foo)
     ;
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/super_parameters/simple.dart.strong.transformed.expect b/pkg/front_end/testcases/super_parameters/simple.dart.strong.transformed.expect
index a1ba70a..2738e5e 100644
--- a/pkg/front_end/testcases/super_parameters/simple.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/super_parameters/simple.dart.strong.transformed.expect
@@ -1,11 +1,4 @@
 library /*isNonNullableByDefault*/;
-//
-// Problems in library:
-//
-// pkg/front_end/testcases/super_parameters/simple.dart:11:3: Error: The superclass, 'A', has no unnamed constructor that takes no arguments.
-//   B(super.foo);
-//   ^
-//
 import self as self;
 import "dart:core" as core;
 
@@ -17,9 +10,7 @@
 }
 class B extends self::A {
   constructor •(dynamic foo) → self::B
-    : final dynamic #t1 = invalid-expression "pkg/front_end/testcases/super_parameters/simple.dart:11:3: Error: The superclass, 'A', has no unnamed constructor that takes no arguments.
-  B(super.foo);
-  ^"
+    : super self::A::•(foo)
     ;
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/super_parameters/simple.dart.weak.expect b/pkg/front_end/testcases/super_parameters/simple.dart.weak.expect
index a1ba70a..2738e5e 100644
--- a/pkg/front_end/testcases/super_parameters/simple.dart.weak.expect
+++ b/pkg/front_end/testcases/super_parameters/simple.dart.weak.expect
@@ -1,11 +1,4 @@
 library /*isNonNullableByDefault*/;
-//
-// Problems in library:
-//
-// pkg/front_end/testcases/super_parameters/simple.dart:11:3: Error: The superclass, 'A', has no unnamed constructor that takes no arguments.
-//   B(super.foo);
-//   ^
-//
 import self as self;
 import "dart:core" as core;
 
@@ -17,9 +10,7 @@
 }
 class B extends self::A {
   constructor •(dynamic foo) → self::B
-    : final dynamic #t1 = invalid-expression "pkg/front_end/testcases/super_parameters/simple.dart:11:3: Error: The superclass, 'A', has no unnamed constructor that takes no arguments.
-  B(super.foo);
-  ^"
+    : super self::A::•(foo)
     ;
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/super_parameters/simple.dart.weak.modular.expect b/pkg/front_end/testcases/super_parameters/simple.dart.weak.modular.expect
index a1ba70a..2738e5e 100644
--- a/pkg/front_end/testcases/super_parameters/simple.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/super_parameters/simple.dart.weak.modular.expect
@@ -1,11 +1,4 @@
 library /*isNonNullableByDefault*/;
-//
-// Problems in library:
-//
-// pkg/front_end/testcases/super_parameters/simple.dart:11:3: Error: The superclass, 'A', has no unnamed constructor that takes no arguments.
-//   B(super.foo);
-//   ^
-//
 import self as self;
 import "dart:core" as core;
 
@@ -17,9 +10,7 @@
 }
 class B extends self::A {
   constructor •(dynamic foo) → self::B
-    : final dynamic #t1 = invalid-expression "pkg/front_end/testcases/super_parameters/simple.dart:11:3: Error: The superclass, 'A', has no unnamed constructor that takes no arguments.
-  B(super.foo);
-  ^"
+    : super self::A::•(foo)
     ;
 }
 static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/super_parameters/simple.dart.weak.transformed.expect b/pkg/front_end/testcases/super_parameters/simple.dart.weak.transformed.expect
index a1ba70a..2738e5e 100644
--- a/pkg/front_end/testcases/super_parameters/simple.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/super_parameters/simple.dart.weak.transformed.expect
@@ -1,11 +1,4 @@
 library /*isNonNullableByDefault*/;
-//
-// Problems in library:
-//
-// pkg/front_end/testcases/super_parameters/simple.dart:11:3: Error: The superclass, 'A', has no unnamed constructor that takes no arguments.
-//   B(super.foo);
-//   ^
-//
 import self as self;
 import "dart:core" as core;
 
@@ -17,9 +10,7 @@
 }
 class B extends self::A {
   constructor •(dynamic foo) → self::B
-    : final dynamic #t1 = invalid-expression "pkg/front_end/testcases/super_parameters/simple.dart:11:3: Error: The superclass, 'A', has no unnamed constructor that takes no arguments.
-  B(super.foo);
-  ^"
+    : super self::A::•(foo)
     ;
 }
 static method main() → dynamic {}
diff --git a/runtime/platform/assert.h b/runtime/platform/assert.h
index ce4d0cc..b021375 100644
--- a/runtime/platform/assert.h
+++ b/runtime/platform/assert.h
@@ -140,13 +140,34 @@
        tols.c_str());
 }
 
+static void Escape(std::ostringstream& dst, const char* src) {
+  char c;
+  while ((c = *src++) != '\0') {
+    if (c == '\n') {
+      dst << "\\n\"\n\"";
+    } else if (c == '\'') {
+      dst << "\\\'";
+    } else if (c == '\"') {
+      dst << "\\\"";
+    } else if (c == '\\') {
+      dst << "\\\\";
+    } else {
+      dst << c;
+    }
+  }
+}
+
 inline void Expect::StringEquals(const char* expected, const char* actual) {
   if (strcmp(expected, actual) == 0) return;
   if (actual == nullptr) {
     Fail("expected:\n<\"%s\">\nbut was nullptr", expected);
   } else {
     if (strcmp(expected, actual) == 0) return;
-    Fail("expected:\n<\"%s\">\nbut was:\n<\"%s\">", expected, actual);
+    std::ostringstream ess, ass;
+    Escape(ess, expected);
+    Escape(ass, actual);
+    std::string es = ess.str(), as = ass.str();
+    Fail("expected:\n<\"%s\">\nbut was:\n<\"%s\">", es.c_str(), as.c_str());
   }
 }
 
diff --git a/runtime/platform/utils.cc b/runtime/platform/utils.cc
index c93c84b..eb833e7 100644
--- a/runtime/platform/utils.cc
+++ b/runtime/platform/utils.cc
@@ -361,7 +361,7 @@
   *error = status != nullptr ? strdup(status) : nullptr;
 #elif defined(DART_HOST_OS_WINDOWS)
   const int status = GetLastError();
-  *error = status != 0 ? Utils::SCreate("error code %i", error) : nullptr;
+  *error = status != 0 ? Utils::SCreate("error code %i", status) : nullptr;
 #else
   *error = Utils::StrDup("loading dynamic libraries is not supported");
 #endif
diff --git a/runtime/vm/compiler/assembler/assembler_arm64_test.cc b/runtime/vm/compiler/assembler/assembler_arm64_test.cc
index f934e32..97ce2ab 100644
--- a/runtime/vm/compiler/assembler/assembler_arm64_test.cc
+++ b/runtime/vm/compiler/assembler/assembler_arm64_test.cc
@@ -31,6 +31,10 @@
 ASSEMBLER_TEST_RUN(Simple, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "add r0, zr, zr\n"
+      "add r0, r0, #0x2a\n"
+      "ret\n");
 }
 
 // Move wide immediate tests.
@@ -43,6 +47,9 @@
 ASSEMBLER_TEST_RUN(Movz0, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Movz1, assembler) {
@@ -54,6 +61,10 @@
 ASSEMBLER_TEST_RUN(Movz1, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42LL << 16, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "movz r0, #0x2a lsl 16\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Movz2, assembler) {
@@ -64,6 +75,9 @@
 ASSEMBLER_TEST_RUN(Movz2, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42LL << 32, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a lsl 32\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Movz3, assembler) {
@@ -74,6 +88,9 @@
 ASSEMBLER_TEST_RUN(Movz3, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42LL << 48, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a lsl 48\n"
+      "ret\n");
 }
 
 // movn
@@ -85,6 +102,9 @@
 ASSEMBLER_TEST_RUN(Movn0, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(~42LL, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Movn1, assembler) {
@@ -95,6 +115,9 @@
 ASSEMBLER_TEST_RUN(Movn1, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(~(42LL << 16), EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r0, #0x2a lsl 16\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Movn2, assembler) {
@@ -105,6 +128,9 @@
 ASSEMBLER_TEST_RUN(Movn2, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(~(42LL << 32), EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r0, #0x2a lsl 32\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Movn3, assembler) {
@@ -115,6 +141,9 @@
 ASSEMBLER_TEST_RUN(Movn3, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(~(42LL << 48), EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r0, #0x2a lsl 48\n"
+      "ret\n");
 }
 
 // movk
@@ -128,6 +157,10 @@
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42LL | (1LL << 48),
             EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x1 lsl 48\n"
+      "movk r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Movk1, assembler) {
@@ -140,6 +173,10 @@
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ((42LL << 16) | 1,
             EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x1\n"
+      "movk r0, #0x2a lsl 16\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Movk2, assembler) {
@@ -152,6 +189,10 @@
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ((42LL << 32) | 1,
             EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x1\n"
+      "movk r0, #0x2a lsl 32\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Movk3, assembler) {
@@ -164,6 +205,10 @@
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ((42LL << 48) | 1,
             EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x1\n"
+      "movk r0, #0x2a lsl 48\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(MovzBig, assembler) {
@@ -174,6 +219,9 @@
 ASSEMBLER_TEST_RUN(MovzBig, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0x8000, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x8000\n"
+      "ret\n");
 }
 
 // add tests.
@@ -187,6 +235,11 @@
 ASSEMBLER_TEST_RUN(AddReg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x14\n"
+      "movz r1, #0x16\n"
+      "add r0, r0, r1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(AddLSLReg, assembler) {
@@ -199,6 +252,11 @@
 ASSEMBLER_TEST_RUN(AddLSLReg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x14\n"
+      "movz r1, #0xb\n"
+      "add r0, r0, r1 lsl #1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(AddLSRReg, assembler) {
@@ -211,6 +269,11 @@
 ASSEMBLER_TEST_RUN(AddLSRReg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x14\n"
+      "movz r1, #0x2c\n"
+      "add r0, r0, r1 lsr #1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(AddASRReg, assembler) {
@@ -223,6 +286,11 @@
 ASSEMBLER_TEST_RUN(AddASRReg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x14\n"
+      "movz r1, #0x2c\n"
+      "add r0, r0, r1 asr #1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(AddASRNegReg, assembler) {
@@ -236,6 +304,12 @@
 ASSEMBLER_TEST_RUN(AddASRNegReg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2b\n"
+      "movn r1, #0x0\n"
+      "add r1, zr, r1 lsl #3\n"
+      "add r0, r0, r1 asr #3\n"
+      "ret\n");
 }
 
 // TODO(zra): test other sign extension modes.
@@ -250,6 +324,12 @@
 ASSEMBLER_TEST_RUN(AddExtReg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2b\n"
+      "movz r1, #0xffff\n"
+      "movk r1, #0xffff lsl 16\n"
+      "add r0, r0, r1 sxtw\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(AddCarryInOut, assembler) {
@@ -265,6 +345,14 @@
 ASSEMBLER_TEST_RUN(AddCarryInOut, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r2, #0x0\n"
+      "movz r1, #0x1\n"
+      "movz r0, #0x0\n"
+      "adds ip0, r2, r1\n"
+      "adcs ip0, r2, r0\n"
+      "adc r0, r0, r0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(SubCarryInOut, assembler) {
@@ -279,6 +367,13 @@
 ASSEMBLER_TEST_RUN(SubCarryInOut, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x1\n"
+      "movz r0, #0x0\n"
+      "subs ip0, r0, r1\n"
+      "sbcs ip0, r0, r0\n"
+      "sbc r0, r0, r0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Overflow, assembler) {
@@ -295,6 +390,15 @@
 ASSEMBLER_TEST_RUN(Overflow, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x0\n"
+      "movz r1, #0x1\n"
+      "movn r2, #0x0\n"
+      "mov r3, 0x7fffffffffffffff\n"
+      "adds ip0, r2, r1\n"
+      "adcs ip0, r3, r0\n"
+      "csinc r0, r0, r0, vs\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(WordAddCarryInOut, assembler) {
@@ -310,6 +414,14 @@
 ASSEMBLER_TEST_RUN(WordAddCarryInOut, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r2, #0x0\n"
+      "movz r1, #0x1\n"
+      "movz r0, #0x0\n"
+      "addws ip0, r2, r1\n"
+      "adcws ip0, r2, r0\n"
+      "adcw r0, r0, r0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(WordSubCarryInOut, assembler) {
@@ -324,6 +436,13 @@
 ASSEMBLER_TEST_RUN(WordSubCarryInOut, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0x0FFFFFFFF, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x1\n"
+      "movz r0, #0x0\n"
+      "subws ip0, r0, r1\n"
+      "sbcws ip0, r0, r0\n"
+      "sbcw r0, r0, r0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(WordOverflow, assembler) {
@@ -340,6 +459,15 @@
 ASSEMBLER_TEST_RUN(WordOverflow, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x0\n"
+      "movz r1, #0x1\n"
+      "mov r2, 0xffffffff\n"
+      "mov r3, 0x7fffffff\n"
+      "addws ip0, r2, r1\n"
+      "adcws ip0, r3, r0\n"
+      "csinc r0, r0, r0, vs\n"
+      "ret\n");
 }
 
 // Loads and Stores.
@@ -360,6 +488,16 @@
 ASSEMBLER_TEST_RUN(SimpleLoadStore, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "sub csp, csp, #0x10\n"
+      "movz r0, #0x2b\n"
+      "movz r1, #0x2a\n"
+      "str r1, [r15, #-8]!\n"
+      "ldr r0, [r15], #8 !\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(SimpleLoadStoreHeapTag, assembler) {
@@ -376,6 +514,16 @@
 ASSEMBLER_TEST_RUN(SimpleLoadStoreHeapTag, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz r0, #0x2b\n"
+      "movz r1, #0x2a\n"
+      "add r2, r15, #0x1\n"
+      "str r1, [r2, #-1]\n"
+      "ldr r0, [r2, #-1]\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadStoreLargeIndex, assembler) {
@@ -399,6 +547,17 @@
 ASSEMBLER_TEST_RUN(LoadStoreLargeIndex, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "sub csp, csp, #0x100\n"
+      "movz r0, #0x2b\n"
+      "movz r1, #0x2a\n"
+      "str r1, [r15, #-256]!\n"
+      "ldr r0, [r15], #248 !\n"
+      "add r15, r15, #0x8\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadStoreLargeOffset, assembler) {
@@ -417,6 +576,18 @@
 ASSEMBLER_TEST_RUN(LoadStoreLargeOffset, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz r0, #0x2b\n"
+      "movz r1, #0x2a\n"
+      "sub r15, r15, #0x1000\n"
+      "and csp, r15, 0xfffffffffffffff0\n"
+      "str r1, [r15, #4096]\n"
+      "add r15, r15, #0x1000\n"
+      "ldr r0, [r15]\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadStoreExtReg, assembler) {
@@ -439,6 +610,20 @@
 ASSEMBLER_TEST_RUN(LoadStoreExtReg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz r0, #0x2b\n"
+      "movz r1, #0x2a\n"
+      "movz r2, #0xfff8\n"
+      "movk r2, #0xffff lsl 16\n"
+      "str r1, [r15, r2 sxtw]\n"
+      "sub r15, r15, #0x8\n"
+      "and csp, r15, 0xfffffffffffffff0\n"
+      "ldr r0, [r15]\n"
+      "add r15, r15, #0x8\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadStoreScaledReg, assembler) {
@@ -459,6 +644,19 @@
 ASSEMBLER_TEST_RUN(LoadStoreScaledReg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz r0, #0x2b\n"
+      "movz r1, #0x2a\n"
+      "movz r2, #0xa\n"
+      "sub r15, r15, #0x50\n"
+      "and csp, r15, 0xfffffffffffffff0\n"
+      "str r1, [r15, r2 uxtx scaled]\n"
+      "ldr r0, [r15, r2 uxtx scaled]\n"
+      "add r15, r15, #0x50\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadSigned32Bit, assembler) {
@@ -478,6 +676,16 @@
 ASSEMBLER_TEST_RUN(LoadSigned32Bit, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "sub csp, csp, #0x10\n"
+      "mov r1, 0xffffffff\n"
+      "strw r1, [r15, #-4]!\n"
+      "ldrsw r0, [r15]\n"
+      "ldrsw r1, [r15], #4 !\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(SimpleLoadStorePair, assembler) {
@@ -498,6 +706,17 @@
 ASSEMBLER_TEST_RUN(SimpleLoadStorePair, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "sub csp, csp, #0x10\n"
+      "movz r2, #0x2b\n"
+      "movz r3, #0x2a\n"
+      "stp r2, r3, [r15, #-16]!\n"
+      "ldp r0, r1, [r15], #16 !\n"
+      "sub r0, r0, r1\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadStorePairOffset, assembler) {
@@ -517,6 +736,19 @@
 ASSEMBLER_TEST_RUN(LoadStorePairOffset, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz r2, #0x2b\n"
+      "movz r3, #0x2a\n"
+      "sub r15, r15, #0x20\n"
+      "and csp, r15, 0xfffffffffffffff0\n"
+      "stp r2, r3, [r15, #16]\n"
+      "ldp r0, r1, [r15, #16]\n"
+      "add r15, r15, #0x20\n"
+      "sub r0, r0, r1\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(PushRegisterPair, assembler) {
@@ -534,6 +766,16 @@
   EXPECT(test != NULL);
   typedef int (*PushRegisterPair)() DART_UNUSED;
   EXPECT_EQ(12, EXECUTE_TEST_CODE_INT64(PushRegisterPair, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz r2, #0xc\n"
+      "movz r3, #0x15\n"
+      "stp r2, r3, [r15, #-16]!\n"
+      "ldr r0, [r15], #8 !\n"
+      "ldr r1, [r15], #8 !\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(PushRegisterPairReversed, assembler) {
@@ -552,6 +794,16 @@
   typedef int (*PushRegisterPairReversed)() DART_UNUSED;
   EXPECT_EQ(12,
             EXECUTE_TEST_CODE_INT64(PushRegisterPairReversed, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz r3, #0xc\n"
+      "movz r2, #0x15\n"
+      "stp r3, r2, [r15, #-16]!\n"
+      "ldr r0, [r15], #8 !\n"
+      "ldr r1, [r15], #8 !\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(PopRegisterPair, assembler) {
@@ -569,6 +821,16 @@
   EXPECT(test != NULL);
   typedef int (*PopRegisterPair)() DART_UNUSED;
   EXPECT_EQ(12, EXECUTE_TEST_CODE_INT64(PopRegisterPair, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz r2, #0xc\n"
+      "movz r3, #0x15\n"
+      "str r3, [r15, #-8]!\n"
+      "str r2, [r15, #-8]!\n"
+      "ldp r0, r1, [r15], #16 !\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(PopRegisterPairReversed, assembler) {
@@ -587,6 +849,16 @@
   typedef int (*PopRegisterPairReversed)() DART_UNUSED;
   EXPECT_EQ(12,
             EXECUTE_TEST_CODE_INT64(PopRegisterPairReversed, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz r3, #0xc\n"
+      "movz r2, #0x15\n"
+      "str r3, [r15, #-8]!\n"
+      "str r2, [r15, #-8]!\n"
+      "ldp r1, r0, [r15], #16 !\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Semaphore, assembler) {
@@ -609,6 +881,19 @@
   EXPECT(test != NULL);
   typedef intptr_t (*Semaphore)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Semaphore, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz r0, #0x28\n"
+      "movz r1, #0x2a\n"
+      "str r0, [r15, #-8]!\n"
+      "ldxr r0, r15\n"
+      "stxr ip0, r1, r15\n"
+      "cmp ip0, #0x0\n"
+      "bne -12\n"
+      "ldr r0, [r15], #8 !\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FailedSemaphore, assembler) {
@@ -629,6 +914,19 @@
   EXPECT(test != NULL);
   typedef intptr_t (*FailedSemaphore)() DART_UNUSED;
   EXPECT_EQ(41, EXECUTE_TEST_CODE_INT64(FailedSemaphore, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz r0, #0x28\n"
+      "movz r1, #0x2a\n"
+      "str r0, [r15, #-8]!\n"
+      "ldxr r0, r15\n"
+      "clrex\n"
+      "stxr ip0, r1, r15\n"
+      "ldr r0, [r15], #8 !\n"
+      "add r0, r0, ip0\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Semaphore32, assembler) {
@@ -660,6 +958,21 @@
   // is unchanged at 40.
   EXPECT_EQ(42 + (DART_INT64_C(40) << 32),
             EXECUTE_TEST_CODE_INT64(Semaphore32, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz r0, #0x28\n"
+      "add r0, r0, r0 lsl #32\n"
+      "str r0, [r15, #-8]!\n"
+      "movz r0, #0x28\n"
+      "movz r1, #0x2a\n"
+      "ldxrw r0, r15\n"
+      "stxrw ip0, r1, r15\n"
+      "cmp ip0, #0x0\n"
+      "bne -12\n"
+      "ldr r0, [r15], #8 !\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FailedSemaphore32, assembler) {
@@ -687,6 +1000,21 @@
   // unchanged at 40.
   EXPECT_EQ(41 + (DART_INT64_C(40) << 32),
             EXECUTE_TEST_CODE_INT64(FailedSemaphore32, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz r0, #0x28\n"
+      "add r0, r0, r0 lsl #32\n"
+      "str r0, [r15, #-8]!\n"
+      "movz r0, #0x28\n"
+      "movz r1, #0x2a\n"
+      "ldxrw r0, r15\n"
+      "clrex\n"
+      "stxrw ip0, r1, r15\n"
+      "ldr r0, [r15], #8 !\n"
+      "add r0, r0, ip0\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadAcquireStoreRelease, assembler) {
@@ -743,6 +1071,68 @@
   typedef intptr_t (*LoadAcquireStoreRelease)() DART_UNUSED;
   EXPECT_EQ(0x42,
             EXECUTE_TEST_CODE_INT64(LoadAcquireStoreRelease, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "stp fp, lr, [r15, #-16]!\n"
+      "mov fp, r15\n"
+      "movz ip0, #0x7788\n"
+      "movk ip0, #0x5566 lsl 16\n"
+      "movk ip0, #0x3344 lsl 32\n"
+      "movk ip0, #0x1122 lsl 48\n"
+      "str ip0, [r15, #-8]!\n"
+      "ldar r1, r15\n"
+      "movz ip1, #0x7788\n"
+      "movk ip1, #0x5566 lsl 16\n"
+      "movk ip1, #0x3344 lsl 32\n"
+      "movk ip1, #0x1122 lsl 48\n"
+      "cmp r1, ip1\n"
+      "bne +164\n"
+      "add r15, r15, #0x8\n"
+      "movz ip0, #0x7788\n"
+      "movk ip0, #0x5566 lsl 16\n"
+      "movk ip0, #0x3344 lsl 32\n"
+      "movk ip0, #0x1122 lsl 48\n"
+      "str ip0, [r15, #-8]!\n"
+      "ldarw r1, r15\n"
+      "movz ip1, #0x7788\n"
+      "movk ip1, #0x5566 lsl 16\n"
+      "cmp r1, ip1\n"
+      "bne +120\n"
+      "add r15, r15, #0x8\n"
+      "movz ip0, #0x0\n"
+      "str ip0, [r15, #-8]!\n"
+      "movz r1, #0x7788\n"
+      "movk r1, #0x5566 lsl 16\n"
+      "movk r1, #0x3344 lsl 32\n"
+      "movk r1, #0x1122 lsl 48\n"
+      "stlr r1, r15\n"
+      "ldr r1, [r15], #8 !\n"
+      "movz ip1, #0x7788\n"
+      "movk ip1, #0x5566 lsl 16\n"
+      "movk ip1, #0x3344 lsl 32\n"
+      "movk ip1, #0x1122 lsl 48\n"
+      "cmp r1, ip1\n"
+      "bne +60\n"
+      "movz ip0, #0x0\n"
+      "str ip0, [r15, #-8]!\n"
+      "movz r1, #0x7788\n"
+      "movk r1, #0x5566 lsl 16\n"
+      "movk r1, #0x3344 lsl 32\n"
+      "movk r1, #0x1122 lsl 48\n"
+      "stlrw r1, r15\n"
+      "ldr r1, [r15], #8 !\n"
+      "movz ip1, #0x7788\n"
+      "movk ip1, #0x5566 lsl 16\n"
+      "cmp r1, ip1\n"
+      "bne +12\n"
+      "movz r0, #0x42\n"
+      "b +8\n"
+      "movz r0, #0x84\n"
+      "mov r15, fp\n"
+      "ldp fp, lr, [r15], #16 !\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 // Logical register operations.
@@ -756,6 +1146,11 @@
 ASSEMBLER_TEST_RUN(AndRegs, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x2b\n"
+      "movz r2, #0x2a\n"
+      "and r0, r1, r2\n"
+      "ret\n");
 }
 
 constexpr uint64_t kU64MinusOne = 0xffffffffffffffffull;
@@ -1242,6 +1637,11 @@
 ASSEMBLER_TEST_RUN(AndShiftRegs, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x2a\n"
+      "movz r2, #0x15\n"
+      "and r0, r1, r2 lsl #1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(BicRegs, assembler) {
@@ -1254,6 +1654,11 @@
 ASSEMBLER_TEST_RUN(BicRegs, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x2a\n"
+      "movz r2, #0x5\n"
+      "bic r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(OrrRegs, assembler) {
@@ -1266,6 +1671,11 @@
 ASSEMBLER_TEST_RUN(OrrRegs, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x20\n"
+      "movz r2, #0xa\n"
+      "orr r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(OrnRegs, assembler) {
@@ -1279,6 +1689,12 @@
 ASSEMBLER_TEST_RUN(OrnRegs, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x20\n"
+      "movn r2, #0x0\n"
+      "movk r2, #0xffd5\n"
+      "orn r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(EorRegs, assembler) {
@@ -1291,6 +1707,11 @@
 ASSEMBLER_TEST_RUN(EorRegs, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0xffd5\n"
+      "movz r2, #0xffff\n"
+      "eor r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(EonRegs, assembler) {
@@ -1303,6 +1724,11 @@
 ASSEMBLER_TEST_RUN(EonRegs, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0xffd5\n"
+      "movn r2, #0xffff\n"
+      "eon r0, r1, r2\n"
+      "ret\n");
 }
 
 // Logical immediate operations.
@@ -1315,6 +1741,10 @@
 ASSEMBLER_TEST_RUN(AndImm, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x2a\n"
+      "and r0, r1, 0xaaaaaaaaaaaaaaaa\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(AndImmCsp, assembler) {
@@ -1331,6 +1761,14 @@
 ASSEMBLER_TEST_RUN(AndImmCsp, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(32, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov ip0, csp\n"
+      "sub ip1, csp, #0x1f\n"
+      "and csp, ip1, 0xfffffffffffffff0\n"
+      "mov r0, csp\n"
+      "sub r0, ip0, r0\n"
+      "mov csp, ip0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(AndOneImm, assembler) {
@@ -1342,6 +1780,10 @@
 ASSEMBLER_TEST_RUN(AndOneImm, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x2b\n"
+      "and r0, r1, 0x1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(OrrImm, assembler) {
@@ -1357,6 +1799,14 @@
 ASSEMBLER_TEST_RUN(OrrImm, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x0\n"
+      "movz r2, #0x3f\n"
+      "movz r3, #0xa\n"
+      "orr r1, r1, 0x20002000200020\n"
+      "orr r1, r1, r3\n"
+      "and r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(EorImm, assembler) {
@@ -1371,6 +1821,13 @@
 ASSEMBLER_TEST_RUN(EorImm, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r0, #0x0\n"
+      "movk r0, #0xffd5\n"
+      "movz r1, #0x3f\n"
+      "eor r0, r0, 0x3f3f3f3f3f3f3f3f\n"
+      "and r0, r0, r1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Clz, assembler) {
@@ -1401,6 +1858,26 @@
 ASSEMBLER_TEST_RUN(Clz, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "clz r1, zr\n"
+      "cmp r1, #0x40\n"
+      "bne +60\n"
+      "movz r2, #0x2a\n"
+      "clz r2, r2\n"
+      "cmp r2, #0x3a\n"
+      "bne +44\n"
+      "movn r0, #0x0\n"
+      "clz r1, r0\n"
+      "cmp r1, #0x0\n"
+      "bne +28\n"
+      "add r0, zr, r0 lsr #3\n"
+      "clz r1, r0\n"
+      "cmp r1, #0x3\n"
+      "bne +12\n"
+      "mov r0, zr\n"
+      "ret\n"
+      "movz r0, #0x1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Clzw, assembler) {
@@ -1439,6 +1916,34 @@
 ASSEMBLER_TEST_RUN(Clzw, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "clzw r1, zr\n"
+      "cmp r1, #0x20\n"
+      "bne +92\n"
+      "movz r2, #0x2a\n"
+      "clzw r2, r2\n"
+      "cmp r2, #0x1a\n"
+      "bne +76\n"
+      "movn r0, #0x0\n"
+      "clzw r1, r0\n"
+      "cmp r1, #0x0\n"
+      "bne +60\n"
+      "add r0, zr, r0 lsr #35\n"
+      "clzw r1, r0\n"
+      "cmp r1, #0x3\n"
+      "bne +44\n"
+      "mov r0, 0xffffffff0fffffff\n"
+      "clzw r1, r0\n"
+      "cmp r1, #0x4\n"
+      "bne +28\n"
+      "mov r0, 0xffffffff\n"
+      "clzw r1, r0\n"
+      "cmp r1, #0x0\n"
+      "bne +12\n"
+      "mov r0, zr\n"
+      "ret\n"
+      "movz r0, #0x1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Rbit, assembler) {
@@ -1452,6 +1957,10 @@
   typedef int64_t (*Int64Return)() DART_UNUSED;
   const int64_t expected = 0xa800000000000000;
   EXPECT_EQ(expected, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x15\n"
+      "rbit r0, r0\n"
+      "ret\n");
 }
 
 // Comparisons, branching.
@@ -1467,6 +1976,11 @@
 ASSEMBLER_TEST_RUN(BranchALForward, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "b +8\n"
+      "movz r0, #0x0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(BranchALBackwards, assembler) {
@@ -1488,6 +2002,15 @@
 ASSEMBLER_TEST_RUN(BranchALBackwards, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "b +16\n"
+      "movz r0, #0x0\n"
+      "ret\n"
+      "movz r0, #0x0\n"
+      "b -8\n"
+      "movz r0, #0x0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CmpEqBranch, assembler) {
@@ -1507,6 +2030,14 @@
 ASSEMBLER_TEST_RUN(CmpEqBranch, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "movz r1, #0xea\n"
+      "movz r2, #0xea\n"
+      "cmp r1, r2\n"
+      "beq +8\n"
+      "movz r0, #0x0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CmpEqBranchNotTaken, assembler) {
@@ -1526,6 +2057,14 @@
 ASSEMBLER_TEST_RUN(CmpEqBranchNotTaken, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x0\n"
+      "movz r1, #0xe9\n"
+      "movz r2, #0xea\n"
+      "cmp r1, r2\n"
+      "beq +8\n"
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CmpEq1Branch, assembler) {
@@ -1544,6 +2083,13 @@
 ASSEMBLER_TEST_RUN(CmpEq1Branch, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "movz r1, #0x1\n"
+      "cmp r1, #0x1\n"
+      "beq +8\n"
+      "movz r0, #0x0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CmnEq1Branch, assembler) {
@@ -1562,6 +2108,13 @@
 ASSEMBLER_TEST_RUN(CmnEq1Branch, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "movn r1, #0x0\n"
+      "cmn r1, #0x1\n"
+      "beq +8\n"
+      "movz r0, #0x0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CmpLtBranch, assembler) {
@@ -1581,6 +2134,14 @@
 ASSEMBLER_TEST_RUN(CmpLtBranch, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "movz r1, #0xe9\n"
+      "movz r2, #0xea\n"
+      "cmp r1, r2\n"
+      "blt +8\n"
+      "movz r0, #0x0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CmpLtBranchNotTaken, assembler) {
@@ -1600,6 +2161,14 @@
 ASSEMBLER_TEST_RUN(CmpLtBranchNotTaken, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x0\n"
+      "movz r1, #0xeb\n"
+      "movz r2, #0xea\n"
+      "cmp r1, r2\n"
+      "blt +8\n"
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CmpBranchIfZero, assembler) {
@@ -1617,6 +2186,12 @@
 ASSEMBLER_TEST_RUN(CmpBranchIfZero, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "movz r1, #0x0\n"
+      "cbz r1, +8\n"
+      "movz r0, #0x0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CmpBranchIfZeroNotTaken, assembler) {
@@ -1634,6 +2209,12 @@
 ASSEMBLER_TEST_RUN(CmpBranchIfZeroNotTaken, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x0\n"
+      "movz r1, #0x1\n"
+      "cbz r1, +8\n"
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CmpBranchIfNotZero, assembler) {
@@ -1651,6 +2232,12 @@
 ASSEMBLER_TEST_RUN(CmpBranchIfNotZero, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "movz r1, #0x1\n"
+      "cbnz r1, +8\n"
+      "movz r0, #0x0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CmpBranchIfNotZeroNotTaken, assembler) {
@@ -1668,6 +2255,12 @@
 ASSEMBLER_TEST_RUN(CmpBranchIfNotZeroNotTaken, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x0\n"
+      "movz r1, #0x0\n"
+      "cbnz r1, +8\n"
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 static const int64_t kBits5And35 = (1 << 5) | (1ll << 35);
@@ -1692,6 +2285,15 @@
 ASSEMBLER_TEST_RUN(TstBranchIfZero, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "movn r1, #0x8 lsl 32\n"
+      "movk r1, #0xffdf\n"
+      "tbzw r1, #5, +8\n"
+      "movz r0, #0x0\n"
+      "tbz r1, #35, +8\n"
+      "movz r0, #0x0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(TstBranchIfZeroNotTaken, assembler) {
@@ -1709,6 +2311,13 @@
 ASSEMBLER_TEST_RUN(TstBranchIfZeroNotTaken, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x0\n"
+      "movz r1, #0x20\n"
+      "movk r1, #0x8 lsl 32\n"
+      "tbzw r1, #5, +8\n"
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(TstBranchIfNotZero, assembler) {
@@ -1731,6 +2340,15 @@
 ASSEMBLER_TEST_RUN(TstBranchIfNotZero, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "movz r1, #0x20\n"
+      "movk r1, #0x8 lsl 32\n"
+      "tbnzw r1, #5, +8\n"
+      "movz r0, #0x0\n"
+      "tbnz r1, #35, +8\n"
+      "movz r0, #0x0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(TstBranchIfNotZeroNotTaken, assembler) {
@@ -1748,6 +2366,13 @@
 ASSEMBLER_TEST_RUN(TstBranchIfNotZeroNotTaken, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x0\n"
+      "movn r1, #0x8 lsl 32\n"
+      "movk r1, #0xffdf\n"
+      "tbnzw r1, #5, +8\n"
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(TstBranchIfZeroFar, assembler) {
@@ -1813,6 +2438,20 @@
 ASSEMBLER_TEST_RUN(FcmpEqBranch, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0x4000 lsl 32\n"
+      "movk ip0, #0x406d lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "movz ip0, #0x4000 lsl 32\n"
+      "movk ip0, #0x406d lsl 48\n"
+      "fmovdr v2, ip0\n"
+      "fcmpd v1, v2\n"
+      "beq +12\n"
+      "movz ip0, #0x0\n"
+      "fmovdr v0, ip0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(TstBranchIfZeroFar1, assembler) {
@@ -1906,6 +2545,20 @@
 ASSEMBLER_TEST_RUN(FcmpEqBranchNotTaken, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x0\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0x2000 lsl 32\n"
+      "movk ip0, #0x406d lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "movz ip0, #0x4000 lsl 32\n"
+      "movk ip0, #0x406d lsl 48\n"
+      "fmovdr v2, ip0\n"
+      "fcmpd v1, v2\n"
+      "beq +12\n"
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FcmpLtBranch, assembler) {
@@ -1944,6 +2597,20 @@
 ASSEMBLER_TEST_RUN(FcmpLtBranchNotTaken, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x0\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0x6000 lsl 32\n"
+      "movk ip0, #0x406d lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "movz ip0, #0x4000 lsl 32\n"
+      "movk ip0, #0x406d lsl 48\n"
+      "fmovdr v2, ip0\n"
+      "fcmpd v1, v2\n"
+      "blt +12\n"
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FcmpzGtBranch, assembler) {
@@ -1964,6 +2631,21 @@
 ASSEMBLER_TEST_RUN(FcmpzGtBranch, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x6000 lsl 32\n"
+      "movk ip0, #0x406d lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0x2000 lsl 32\n"
+      "movk ip0, #0x406d lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fcmpd v1, #0.0\n"
+      "bgt +16\n"
+      "movz ip0, #0x0\n"
+      "fmovdr v0, ip0\n"
+      "ret\n"
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(AndsBranch, assembler) {
@@ -1983,6 +2665,14 @@
 ASSEMBLER_TEST_RUN(AndsBranch, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "movz r1, #0x2\n"
+      "movz r2, #0x1\n"
+      "ands r3, r1, r2\n"
+      "beq +8\n"
+      "movz r0, #0x0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(AndsBranchNotTaken, assembler) {
@@ -2002,6 +2692,14 @@
 ASSEMBLER_TEST_RUN(AndsBranchNotTaken, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x0\n"
+      "movz r1, #0x2\n"
+      "movz r2, #0x2\n"
+      "ands r3, r1, r2\n"
+      "beq +8\n"
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(BicsBranch, assembler) {
@@ -2021,6 +2719,14 @@
 ASSEMBLER_TEST_RUN(BicsBranch, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "movz r1, #0x2\n"
+      "movz r2, #0x2\n"
+      "bics r3, r1, r2\n"
+      "beq +8\n"
+      "movz r0, #0x0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(BicsBranchNotTaken, assembler) {
@@ -2040,6 +2746,14 @@
 ASSEMBLER_TEST_RUN(BicsBranchNotTaken, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x0\n"
+      "movz r1, #0x2\n"
+      "movz r2, #0x1\n"
+      "bics r3, r1, r2\n"
+      "beq +8\n"
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(AndisBranch, assembler) {
@@ -2058,6 +2772,13 @@
 ASSEMBLER_TEST_RUN(AndisBranch, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "movz r1, #0x2\n"
+      "ands r3, r1, 0x1\n"
+      "beq +8\n"
+      "movz r0, #0x0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(AndisBranchNotTaken, assembler) {
@@ -2076,6 +2797,13 @@
 ASSEMBLER_TEST_RUN(AndisBranchNotTaken, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x0\n"
+      "movz r1, #0x2\n"
+      "ands r3, r1, 0x2\n"
+      "beq +8\n"
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 // Address of PC-rel offset, br, blr.
@@ -2129,6 +2857,12 @@
   EXPECT(test != NULL);
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(3, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x1b\n"
+      "movz r1, #0x9\n"
+      "udiv r2, r0, r1\n"
+      "mov r0, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Sdiv, assembler) {
@@ -2144,6 +2878,13 @@
   EXPECT(test != NULL);
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-3, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x1b\n"
+      "movz r1, #0x9\n"
+      "neg r1, r1\n"
+      "sdiv r2, r0, r1\n"
+      "mov r0, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Udiv_zero, assembler) {
@@ -2158,6 +2899,12 @@
   EXPECT(test != NULL);
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x1b\n"
+      "movz r1, #0x0\n"
+      "udiv r2, r0, r1\n"
+      "mov r0, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Sdiv_zero, assembler) {
@@ -2172,6 +2919,12 @@
   EXPECT(test != NULL);
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x1b\n"
+      "movz r1, #0x0\n"
+      "sdiv r2, r0, r1\n"
+      "mov r0, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Udiv_corner, assembler) {
@@ -2186,6 +2939,12 @@
   EXPECT(test != NULL);
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x8000 lsl 48\n"
+      "movn r1, #0x0\n"
+      "udiv r2, r0, r1\n"
+      "mov r0, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Sdiv_corner, assembler) {
@@ -2201,6 +2960,12 @@
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(static_cast<int64_t>(0x8000000000000000),
             EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r3, #0x8000 lsl 48\n"
+      "movn r1, #0x0\n"
+      "sdiv r2, r3, r1\n"
+      "mov r0, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Lslv, assembler) {
@@ -2213,6 +2978,11 @@
 ASSEMBLER_TEST_RUN(Lslv, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x15\n"
+      "movz r2, #0x1\n"
+      "lsl r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Lsrv, assembler) {
@@ -2225,6 +2995,11 @@
 ASSEMBLER_TEST_RUN(Lsrv, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x54\n"
+      "movz r2, #0x1\n"
+      "lsr r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LShiftingV, assembler) {
@@ -2238,6 +3013,12 @@
 ASSEMBLER_TEST_RUN(LShiftingV, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x1\n"
+      "movz r2, #0x3f\n"
+      "lsl r1, r1, r2\n"
+      "lsr r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(RShiftingV, assembler) {
@@ -2251,6 +3032,12 @@
 ASSEMBLER_TEST_RUN(RShiftingV, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x1\n"
+      "movz r2, #0x3f\n"
+      "lsl r1, r1, r2\n"
+      "asr r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Mult_pos, assembler) {
@@ -2263,6 +3050,11 @@
 ASSEMBLER_TEST_RUN(Mult_pos, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x6\n"
+      "movz r2, #0x7\n"
+      "mul r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Mult_neg, assembler) {
@@ -2276,6 +3068,12 @@
 ASSEMBLER_TEST_RUN(Mult_neg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x6\n"
+      "movz r2, #0x7\n"
+      "neg r2, r2\n"
+      "mul r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Smulh_pos, assembler) {
@@ -2288,6 +3086,11 @@
 ASSEMBLER_TEST_RUN(Smulh_pos, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x6\n"
+      "movz r2, #0x7\n"
+      "smulh r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Smulh_neg, assembler) {
@@ -2301,6 +3104,12 @@
 ASSEMBLER_TEST_RUN(Smulh_neg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x6\n"
+      "movz r2, #0x7\n"
+      "neg r2, r2\n"
+      "smulh r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Umulh, assembler) {
@@ -2314,6 +3123,11 @@
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(static_cast<int64_t>(0x6fff900000000),
             EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0xffff lsl 48\n"
+      "movz r2, #0x7 lsl 48\n"
+      "umulh r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Umaddl, assembler) {
@@ -2327,6 +3141,12 @@
 ASSEMBLER_TEST_RUN(Umaddl, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0x700000001, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r1, #0x0\n"
+      "movz r2, #0x7\n"
+      "movz r3, #0x8\n"
+      "umaddl r0, r1, r2, r3\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Smaddl, assembler) {
@@ -2340,6 +3160,12 @@
 ASSEMBLER_TEST_RUN(Smaddl, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(6, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r1, #0x1\n"
+      "movz r2, #0x7\n"
+      "movz r3, #0x14\n"
+      "smaddl r0, r1, r2, r3\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Smaddl2, assembler) {
@@ -2352,6 +3178,11 @@
 ASSEMBLER_TEST_RUN(Smaddl2, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(2, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r1, #0x1\n"
+      "movn r2, #0x0\n"
+      "smull r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Smaddl3, assembler) {
@@ -2365,6 +3196,11 @@
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0xffffl * 0xffffl,
             EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0xffff\n"
+      "movz r2, #0xffff\n"
+      "smull r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(SmaddlOverflow, assembler) {
@@ -2385,6 +3221,17 @@
 ASSEMBLER_TEST_RUN(SmaddlOverflow, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0xffff\n"
+      "add r1, r1, #0x4\n"
+      "movz r2, #0x7fff\n"
+      "smull r0, r1, r2\n"
+      "asr r3, r0, #31\n"
+      "cmp r3, r0 asr #63\n"
+      "bne +8\n"
+      "ret\n"
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(SmaddlOverflow2, assembler) {
@@ -2405,6 +3252,17 @@
 ASSEMBLER_TEST_RUN(SmaddlOverflow2, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0xffff\n"
+      "movn r2, #0xffff\n"
+      "sub r2, r2, #0x3\n"
+      "smull r0, r1, r2\n"
+      "asr r3, r0, #31\n"
+      "cmp r3, r0 asr #63\n"
+      "bne +8\n"
+      "ret\n"
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(SmaddlOverflow3, assembler) {
@@ -2424,12 +3282,24 @@
 ASSEMBLER_TEST_RUN(SmaddlOverflow3, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x7fff\n"
+      "movk r1, #0x100 lsl 16\n"
+      "movz r2, #0x7fff\n"
+      "movk r2, #0x100 lsl 16\n"
+      "smull r0, r1, r2\n"
+      "asr r3, r0, #31\n"
+      "cmp r3, r0 asr #63\n"
+      "bne +8\n"
+      "ret\n"
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(NegNoOverflow, assembler) {
   Label return_ltuae;
   __ LoadImmediate(R1, 0x7fffffff);
-  __ negsw(R0, R1);  // X0 = W1*W2, alias of smaddl.
+  __ negsw(R0, R1);
   __ sxtw(R0, R0);
   __ b(&return_ltuae, VS);  // Branch on overflow set.
   __ ret();
@@ -2441,12 +3311,20 @@
 ASSEMBLER_TEST_RUN(NegNoOverflow, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-0x7fffffff, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r1, 0x7fffffff\n"
+      "negws r0, r1\n"
+      "sxtw r0, r0\n"
+      "bvs +8\n"
+      "ret\n"
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(NegNoOverflow2, assembler) {
   Label return_ltuae;
   __ LoadImmediate(R1, 0x7123);
-  __ negsw(R0, R1);  // X0 = W1*W2, alias of smaddl.
+  __ negsw(R0, R1);
   __ sxtw(R0, R0);
   __ b(&return_ltuae, VS);  // Branch on overflow set.
   __ ret();
@@ -2458,6 +3336,14 @@
 ASSEMBLER_TEST_RUN(NegNoOverflow2, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-0x7123, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x7123\n"
+      "negws r0, r1\n"
+      "sxtw r0, r0\n"
+      "bvs +8\n"
+      "ret\n"
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(NegOverflow, assembler) {
@@ -2475,6 +3361,14 @@
 ASSEMBLER_TEST_RUN(NegOverflow, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r1, 0xffffffff80000000\n"
+      "negws r0, r1\n"
+      "sxtw r0, r0\n"
+      "bvs +8\n"
+      "ret\n"
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 // Loading immediate values without the object pool.
@@ -2486,6 +3380,9 @@
 ASSEMBLER_TEST_RUN(LoadImmediateSmall, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateMed, assembler) {
@@ -2496,6 +3393,10 @@
 ASSEMBLER_TEST_RUN(LoadImmediateMed, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0xf1234123, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x4123\n"
+      "movk r0, #0xf123 lsl 16\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateMed2, assembler) {
@@ -2507,6 +3408,11 @@
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0x4321f1234123,
             EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x4123\n"
+      "movk r0, #0xf123 lsl 16\n"
+      "movk r0, #0x4321 lsl 32\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateLarge, assembler) {
@@ -2518,6 +3424,12 @@
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(static_cast<int64_t>(0x9287436598237465),
             EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x7465\n"
+      "movk r0, #0x9823 lsl 16\n"
+      "movk r0, #0x4365 lsl 32\n"
+      "movk r0, #0x9287 lsl 48\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateSmallNeg, assembler) {
@@ -2528,6 +3440,9 @@
 ASSEMBLER_TEST_RUN(LoadImmediateSmallNeg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r0, #0x29\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg, assembler) {
@@ -2538,6 +3453,11 @@
 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-0x1212341234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r0, #0x12 lsl 32\n"
+      "movk r0, #0xedcb lsl 16\n"
+      "movk r0, #0xedcc\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg2, assembler) {
@@ -2548,6 +3468,11 @@
 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg2, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-0x1212340000, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r0, #0x12 lsl 32\n"
+      "movk r0, #0xedcc lsl 16\n"
+      "movk r0, #0x0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg3, assembler) {
@@ -2558,6 +3483,10 @@
 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg3, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-0x1200001234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r0, #0x12 lsl 32\n"
+      "movk r0, #0xedcc\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg4, assembler) {
@@ -2568,6 +3497,10 @@
 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg4, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-0x12341234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r0, #0x1234 lsl 16\n"
+      "movk r0, #0xedcc\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadHalfWordUnaligned, assembler) {
@@ -2591,6 +3524,10 @@
       static_cast<int16_t>(static_cast<uint16_t>(0xCDAB)),
       EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadHalfWordUnaligned, test->entry(),
                                       reinterpret_cast<intptr_t>(&buffer[1])));
+  EXPECT_DISASSEMBLY(
+      "ldrsh r1, [r0]\n"
+      "mov r0, r1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadHalfWordUnsignedUnaligned, assembler) {
@@ -2612,6 +3549,10 @@
   EXPECT_EQ(0xCDAB, EXECUTE_TEST_CODE_INTPTR_INTPTR(
                         LoadHalfWordUnsignedUnaligned, test->entry(),
                         reinterpret_cast<intptr_t>(&buffer[1])));
+  EXPECT_DISASSEMBLY(
+      "ldrh r1, [r0]\n"
+      "mov r0, r1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(StoreHalfWordUnaligned, assembler) {
@@ -2641,6 +3582,11 @@
   EXPECT_EQ(0xCD, buffer[1]);
   EXPECT_EQ(0xAB, buffer[2]);
   EXPECT_EQ(0, buffer[3]);
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0xabcd\n"
+      "strh r1, [r0]\n"
+      "mov r0, r1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(LoadWordUnaligned, assembler) {
@@ -2670,6 +3616,10 @@
       static_cast<int32_t>(0xDEBC9A78),
       EXECUTE_TEST_CODE_INT32_INTPTR(LoadWordUnaligned, test->entry(),
                                      reinterpret_cast<intptr_t>(&buffer[3])));
+  EXPECT_DISASSEMBLY(
+      "ldrw r1, [r0]\n"
+      "mov r0, r1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(StoreWordUnaligned, assembler) {
@@ -2715,6 +3665,13 @@
   EXPECT_EQ(0x56, buffer[4]);
   EXPECT_EQ(0x34, buffer[5]);
   EXPECT_EQ(0x12, buffer[6]);
+
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x5678\n"
+      "movk r1, #0x1234 lsl 16\n"
+      "strw r1, [r0]\n"
+      "mov r0, r1\n"
+      "ret\n");
 }
 
 static void EnterTestFrame(Assembler* assembler) {
@@ -2882,6 +3839,12 @@
 ASSEMBLER_TEST_RUN(CSelTrue, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x2a\n"
+      "movz r2, #0x4d2\n"
+      "cmp r1, r2\n"
+      "csel r0, r1, r2, lt\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CSelFalse, assembler) {
@@ -2895,6 +3858,12 @@
 ASSEMBLER_TEST_RUN(CSelFalse, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x2a\n"
+      "movz r2, #0x4d2\n"
+      "cmp r1, r2\n"
+      "csel r0, r1, r2, ge\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CsincFalse, assembler) {
@@ -2921,6 +3890,12 @@
 ASSEMBLER_TEST_RUN(CsincTrue, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x2a\n"
+      "movz r2, #0x4d2\n"
+      "cmp r1, r2\n"
+      "cinc r0, r2, ge\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CsinvFalse, assembler) {
@@ -2934,6 +3909,12 @@
 ASSEMBLER_TEST_RUN(CsinvFalse, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(~42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x2a\n"
+      "movz r2, #0x4d2\n"
+      "cmp r1, r2\n"
+      "csinv r0, r2, r1, ge\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CsinvTrue, assembler) {
@@ -2947,6 +3928,12 @@
 ASSEMBLER_TEST_RUN(CsinvTrue, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x2a\n"
+      "movz r2, #0x4d2\n"
+      "cmp r1, r2\n"
+      "csinv r0, r2, r1, lt\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CsnegFalse, assembler) {
@@ -2960,6 +3947,12 @@
 ASSEMBLER_TEST_RUN(CsnegFalse, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x2a\n"
+      "movz r2, #0x4d2\n"
+      "cmp r1, r2\n"
+      "csneg r0, r2, r1, ge\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CsnegTrue, assembler) {
@@ -2973,6 +3966,12 @@
 ASSEMBLER_TEST_RUN(CsnegTrue, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(1234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x2a\n"
+      "movz r2, #0x4d2\n"
+      "cmp r1, r2\n"
+      "csneg r0, r2, r1, lt\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Ubfx, assembler) {
@@ -2985,6 +3984,12 @@
 ASSEMBLER_TEST_RUN(Ubfx, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0x81, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x819\n"
+      "movz r0, #0x5a5a\n"
+      "movk r0, #0x5a5a lsl 16\n"
+      "ubfm r0, r1, #4, #11\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Sbfx, assembler) {
@@ -2997,6 +4002,12 @@
 ASSEMBLER_TEST_RUN(Sbfx, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-0x7f, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x819\n"
+      "movz r0, #0x5a5a\n"
+      "movk r0, #0x5a5a lsl 16\n"
+      "sbfm r0, r1, #4, #11\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Bfi, assembler) {
@@ -3009,6 +4020,12 @@
 ASSEMBLER_TEST_RUN(Bfi, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0x5a5b9a5a, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x819\n"
+      "movz r0, #0x5a5a\n"
+      "movk r0, #0x5a5a lsl 16\n"
+      "bfm r0, r1, #52, #4\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Ubfiz, assembler) {
@@ -3022,6 +4039,13 @@
 ASSEMBLER_TEST_RUN(Ubfiz, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0x7e2491fe, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x48ff\n"
+      "movk r1, #0xff12 lsl 16\n"
+      "movz r0, #0x5a5a\n"
+      "movk r0, #0x5a5a lsl 16\n"
+      "ubfm r0, r1, #63, #29\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Bfxil, assembler) {
@@ -3034,6 +4058,12 @@
 ASSEMBLER_TEST_RUN(Bfxil, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0x5a5a5a81, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x819\n"
+      "movz r0, #0x5a5a\n"
+      "movk r0, #0x5a5a lsl 16\n"
+      "bfm r0, r1, #4, #11\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Sbfiz, assembler) {
@@ -3046,6 +4076,12 @@
 ASSEMBLER_TEST_RUN(Sbfiz, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-0x7e70, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0x819\n"
+      "movz r0, #0x5a5a\n"
+      "movk r0, #0x5a5a lsl 16\n"
+      "sbfm r0, r1, #60, #11\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Sxtb, assembler) {
@@ -3062,6 +4098,17 @@
 ASSEMBLER_TEST_RUN(Sxtb, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0x29, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r1, #0xff\n"
+      "movz r0, #0x5a5a\n"
+      "movk r0, #0x5a5a lsl 16\n"
+      "sxtb r0, r1\n"
+      "movz r2, #0x2a\n"
+      "movz r1, #0x5a5a\n"
+      "movk r1, #0x5a5a lsl 16\n"
+      "sxtb r1, r2\n"
+      "add r0, r0, r1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Sxth, assembler) {
@@ -3078,6 +4125,18 @@
 ASSEMBLER_TEST_RUN(Sxth, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0x29, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r1, 0xffff\n"
+      "movz r0, #0x5a5a\n"
+      "movk r0, #0x5a5a lsl 16\n"
+      "sxth r0, r1\n"
+      "movz r2, #0x2a\n"
+      "movk r2, #0x1 lsl 16\n"
+      "movz r1, #0x5a5a\n"
+      "movk r1, #0x5a5a lsl 16\n"
+      "sxth r1, r2\n"
+      "add r0, r0, r1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Sxtw, assembler) {
@@ -3094,6 +4153,18 @@
 ASSEMBLER_TEST_RUN(Sxtw, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0x29, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r1, 0xffffffff\n"
+      "movz r0, #0x5a5a\n"
+      "movk r0, #0x5a5a lsl 16\n"
+      "sxtw r0, r1\n"
+      "movz r2, #0x2a\n"
+      "movk r2, #0x1 lsl 32\n"
+      "movz r1, #0x5a5a\n"
+      "movk r1, #0x5a5a lsl 16\n"
+      "sxtw r1, r2\n"
+      "add r0, r0, r1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Uxtw, assembler) {
@@ -3111,6 +4182,18 @@
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0xffffffffll + 42,
             EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r1, 0xffffffff\n"
+      "movz r0, #0x5a5a\n"
+      "movk r0, #0x5a5a lsl 16\n"
+      "ubfm r0, r1, #0, #31\n"
+      "movz r2, #0x2a\n"
+      "movk r2, #0x1 lsl 32\n"
+      "movz r1, #0x5a5a\n"
+      "movk r1, #0x5a5a lsl 16\n"
+      "ubfm r1, r2, #0, #31\n"
+      "add r0, r0, r1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Uxtb, assembler) {
@@ -3127,6 +4210,17 @@
 ASSEMBLER_TEST_RUN(Uxtb, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0xff + 0x2a, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r1, #0x0\n"
+      "movz r0, #0x5a5a\n"
+      "movk r0, #0x5a5a lsl 16\n"
+      "uxtb r0, r1\n"
+      "movz r2, #0x12a\n"
+      "movz r1, #0x5a5a\n"
+      "movk r1, #0x5a5a lsl 16\n"
+      "uxtb r1, r2\n"
+      "add r0, r0, r1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Uxth, assembler) {
@@ -3143,6 +4237,18 @@
 ASSEMBLER_TEST_RUN(Uxth, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0xffff + 0x2a, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movn r1, #0x0\n"
+      "movz r0, #0x5a5a\n"
+      "movk r0, #0x5a5a lsl 16\n"
+      "uxth r0, r1\n"
+      "movz r2, #0x2a\n"
+      "movk r2, #0x1 lsl 16\n"
+      "movz r1, #0x5a5a\n"
+      "movk r1, #0x5a5a lsl 16\n"
+      "uxth r1, r2\n"
+      "add r0, r0, r1\n"
+      "ret\n");
 }
 
 // Floating point move immediate, to/from integer register.
@@ -3154,6 +4260,9 @@
 ASSEMBLER_TEST_RUN(Fmovdi, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(1.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "fmovd v0, 1.000000\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fmovdi2, assembler) {
@@ -3166,6 +4275,13 @@
   EXPECT_FLOAT_EQ(123412983.1324524315,
                   EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()),
                   0.0001f);
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0xa19c\n"
+      "movk ip0, #0xdc87 lsl 16\n"
+      "movk ip0, #0x6c87 lsl 32\n"
+      "movk ip0, #0x419d lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fmovrd, assembler) {
@@ -3178,6 +4294,10 @@
   typedef int64_t (*Int64Return)() DART_UNUSED;
   const int64_t one = bit_cast<int64_t, double>(1.0);
   EXPECT_EQ(one, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "fmovd v1, 1.000000\n"
+      "fmovrd r0, v1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fmovdr, assembler) {
@@ -3190,6 +4310,11 @@
 ASSEMBLER_TEST_RUN(Fmovdr, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(1.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "fmovd v1, 1.000000\n"
+      "fmovrd r1, v1\n"
+      "fmovdr v0, r1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fmovrs, assembler) {
@@ -3204,6 +4329,11 @@
   int64_t result = EXECUTE_TEST_CODE_INT64(Int64Return, test->entry());
   const uint32_t one = bit_cast<uint32_t, float>(1.0f);
   EXPECT_EQ(one, static_cast<uint32_t>(result));
+  EXPECT_DISASSEMBLY(
+      "fmovd v2, 1.000000\n"
+      "fcvtsd v1, v2\n"
+      "fmovrsw r0, v1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fmovsr, assembler) {
@@ -3218,6 +4348,11 @@
   int64_t result = EXECUTE_TEST_CODE_INT64(Int64Return, test->entry());
   const uint32_t one = bit_cast<uint32_t, float>(1.0f);
   EXPECT_EQ(one, static_cast<uint32_t>(result));
+  EXPECT_DISASSEMBLY(
+      "mov r2, 0x3f800000\n"
+      "fmovsrw v1, r2\n"
+      "fmovrsw r0, v1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdPrePostIndex, assembler) {
@@ -3236,6 +4371,16 @@
 ASSEMBLER_TEST_RUN(FldrdFstrdPrePostIndex, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "sub csp, csp, #0x10\n"
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fstrd v1, [r15, #-8]!\n"
+      "fldrd v0, [r15], #8 !\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FldrsFstrsPrePostIndex, assembler) {
@@ -3256,6 +4401,18 @@
 ASSEMBLER_TEST_RUN(FldrsFstrsPrePostIndex, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "sub csp, csp, #0x10\n"
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fcvtsd v2, v1\n"
+      "fstrs v2, [r15, #-8]!\n"
+      "fldrs v3, [r15], #8 !\n"
+      "fcvtds v0, v3\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FldrqFstrqPrePostIndex, assembler) {
@@ -3283,6 +4440,24 @@
 ASSEMBLER_TEST_RUN(FldrqFstrqPrePostIndex, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "sub csp, csp, #0x10\n"
+      "fmovd v1, 21.000000\n"
+      "fmovd v2, 21.000000\n"
+      "movz r1, #0x2a\n"
+      "str r1, [r15, #-8]!\n"
+      "fstrd v1, [r15, #-8]!\n"
+      "fstrd v2, [r15, #-8]!\n"
+      "fldrq v3, [r15], #16 !\n"
+      "ldr r0, [r15], #8 !\n"
+      "fstrq v3, [r15, #-16]!\n"
+      "fldrd v0, [r15], #8 !\n"
+      "fldrd v1, [r15], #8 !\n"
+      "faddd v0, v0, v1\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtzsxd, assembler) {
@@ -3294,6 +4469,12 @@
 ASSEMBLER_TEST_RUN(Fcvtzsxd, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4000 lsl 32\n"
+      "movk ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtzs r0, v0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtzswd, assembler) {
@@ -3306,6 +4487,13 @@
 ASSEMBLER_TEST_RUN(Fcvtzswd, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4000 lsl 32\n"
+      "movk ip0, #0xc045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtzsw r0, v0\n"
+      "sxtw r0, r0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtzsxd_overflow, assembler) {
@@ -3328,6 +4516,14 @@
 ASSEMBLER_TEST_RUN(Fcvtzsxd_overflow_negative, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(kMinInt64, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x8c40\n"
+      "movk ip0, #0x78b5 lsl 16\n"
+      "movk ip0, #0xaf1d lsl 32\n"
+      "movk ip0, #0xc415 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtzs r0, v0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtzswd_overflow, assembler) {
@@ -3339,6 +4535,13 @@
 ASSEMBLER_TEST_RUN(Fcvtzswd_overflow, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(kMaxInt32, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x2000 lsl 16\n"
+      "movk ip0, #0xa05f lsl 32\n"
+      "movk ip0, #0x4202 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtzsw r0, v0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtzswd_overflow_negative, assembler) {
@@ -3351,6 +4554,14 @@
 ASSEMBLER_TEST_RUN(Fcvtzswd_overflow_negative, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(kMinInt32, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x2000 lsl 16\n"
+      "movk ip0, #0xa05f lsl 32\n"
+      "movk ip0, #0xc202 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtzsw r0, v0\n"
+      "sxtw r0, r0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtpsxd, assembler) {
@@ -3362,6 +4573,12 @@
 ASSEMBLER_TEST_RUN(Fcvtpsxd, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(43, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4000 lsl 32\n"
+      "movk ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtps r0, v0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtpswd, assembler) {
@@ -3374,6 +4591,13 @@
 ASSEMBLER_TEST_RUN(Fcvtpswd, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4000 lsl 32\n"
+      "movk ip0, #0xc045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtpsw r0, v0\n"
+      "sxtw r0, r0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtpsxd_overflow, assembler) {
@@ -3385,6 +4609,14 @@
 ASSEMBLER_TEST_RUN(Fcvtpsxd_overflow, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(kMaxInt64, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x8c40\n"
+      "movk ip0, #0x78b5 lsl 16\n"
+      "movk ip0, #0xaf1d lsl 32\n"
+      "movk ip0, #0x4415 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtps r0, v0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtpsxd_overflow_negative, assembler) {
@@ -3396,6 +4628,14 @@
 ASSEMBLER_TEST_RUN(Fcvtpsxd_overflow_negative, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(kMinInt64, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x8c40\n"
+      "movk ip0, #0x78b5 lsl 16\n"
+      "movk ip0, #0xaf1d lsl 32\n"
+      "movk ip0, #0xc415 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtps r0, v0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtpswd_overflow, assembler) {
@@ -3407,6 +4647,13 @@
 ASSEMBLER_TEST_RUN(Fcvtpswd_overflow, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(kMaxInt32, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x2000 lsl 16\n"
+      "movk ip0, #0xa05f lsl 32\n"
+      "movk ip0, #0x4202 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtpsw r0, v0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtpswd_overflow_negative, assembler) {
@@ -3419,6 +4666,14 @@
 ASSEMBLER_TEST_RUN(Fcvtpswd_overflow_negative, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(kMinInt32, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x2000 lsl 16\n"
+      "movk ip0, #0xa05f lsl 32\n"
+      "movk ip0, #0xc202 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtpsw r0, v0\n"
+      "sxtw r0, r0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtmsxd, assembler) {
@@ -3430,6 +4685,12 @@
 ASSEMBLER_TEST_RUN(Fcvtmsxd, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4000 lsl 32\n"
+      "movk ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtms r0, v0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtmswd, assembler) {
@@ -3442,6 +4703,13 @@
 ASSEMBLER_TEST_RUN(Fcvtmswd, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-43, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4000 lsl 32\n"
+      "movk ip0, #0xc045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtmsw r0, v0\n"
+      "sxtw r0, r0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtmsxd_overflow, assembler) {
@@ -3453,6 +4721,14 @@
 ASSEMBLER_TEST_RUN(Fcvtmsxd_overflow, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(kMaxInt64, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x8c40\n"
+      "movk ip0, #0x78b5 lsl 16\n"
+      "movk ip0, #0xaf1d lsl 32\n"
+      "movk ip0, #0x4415 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtms r0, v0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtmsxd_overflow_negative, assembler) {
@@ -3464,6 +4740,14 @@
 ASSEMBLER_TEST_RUN(Fcvtmsxd_overflow_negative, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(kMinInt64, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x8c40\n"
+      "movk ip0, #0x78b5 lsl 16\n"
+      "movk ip0, #0xaf1d lsl 32\n"
+      "movk ip0, #0xc415 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtms r0, v0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtmswd_overflow, assembler) {
@@ -3475,6 +4759,13 @@
 ASSEMBLER_TEST_RUN(Fcvtmswd_overflow, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(kMaxInt32, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x2000 lsl 16\n"
+      "movk ip0, #0xa05f lsl 32\n"
+      "movk ip0, #0x4202 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtmsw r0, v0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fcvtmswd_overflow_negative, assembler) {
@@ -3487,6 +4778,14 @@
 ASSEMBLER_TEST_RUN(Fcvtmswd_overflow_negative, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(kMinInt32, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x2000 lsl 16\n"
+      "movk ip0, #0xa05f lsl 32\n"
+      "movk ip0, #0xc202 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtmsw r0, v0\n"
+      "sxtw r0, r0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Scvtfdx, assembler) {
@@ -3498,6 +4797,10 @@
 ASSEMBLER_TEST_RUN(Scvtfdx, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "scvtfd v0, r0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Scvtfdw, assembler) {
@@ -3510,6 +4813,12 @@
 ASSEMBLER_TEST_RUN(Scvtfdw, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "movk r0, #0x1111 lsl 32\n"
+      "movk r0, #0x1111 lsl 48\n"
+      "scvtfdw v0, r0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FabsdPos, assembler) {
@@ -3521,6 +4830,11 @@
 ASSEMBLER_TEST_RUN(FabsdPos, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fabsd v0, v1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FabsdNeg, assembler) {
@@ -3532,6 +4846,11 @@
 ASSEMBLER_TEST_RUN(FabsdNeg, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0xc045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fabsd v0, v1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FnegdPos, assembler) {
@@ -3543,6 +4862,11 @@
 ASSEMBLER_TEST_RUN(FnegdPos, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(-42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fnegd v0, v1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FnegdNeg, assembler) {
@@ -3554,6 +4878,11 @@
 ASSEMBLER_TEST_RUN(FnegdNeg, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0xc045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fnegd v0, v1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fsqrtd, assembler) {
@@ -3565,6 +4894,11 @@
 ASSEMBLER_TEST_RUN(Fsqrtd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(8.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4050 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fsqrtd v0, v1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fmuld, assembler) {
@@ -3577,6 +4911,12 @@
 ASSEMBLER_TEST_RUN(Fmuld, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4055 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fmovd v2, 0.500000\n"
+      "fmuld v0, v1, v2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fdivd, assembler) {
@@ -3589,6 +4929,12 @@
 ASSEMBLER_TEST_RUN(Fdivd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4055 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fmovd v2, 2.000000\n"
+      "fdivd v0, v1, v2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Faddd, assembler) {
@@ -3601,6 +4947,13 @@
 ASSEMBLER_TEST_RUN(Faddd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0xc000 lsl 32\n"
+      "movk ip0, #0x4044 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fmovd v2, 0.500000\n"
+      "faddd v0, v1, v2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Fsubd, assembler) {
@@ -3613,6 +4966,13 @@
 ASSEMBLER_TEST_RUN(Fsubd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4000 lsl 32\n"
+      "movk ip0, #0x4045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fmovd v2, 0.500000\n"
+      "fsubd v0, v1, v2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdHeapTag, assembler) {
@@ -3631,6 +4991,21 @@
 ASSEMBLER_TEST_RUN(FldrdFstrdHeapTag, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz ip0, #0x8000 lsl 32\n"
+      "movk ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "sub r15, r15, #0x8\n"
+      "add r2, r15, #0x1\n"
+      "fstrd v1, [r2, #-1]\n"
+      "fldrd v0, [r2, #-1]\n"
+      "add r15, r15, #0x8\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdLargeIndex, assembler) {
@@ -3654,6 +5029,20 @@
 ASSEMBLER_TEST_RUN(FldrdFstrdLargeIndex, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "sub csp, csp, #0x100\n"
+      "movz ip0, #0x8000 lsl 32\n"
+      "movk ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fstrd v1, [r15, #-256]!\n"
+      "fldrd v0, [r15], #248 !\n"
+      "add r15, r15, #0x8\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdLargeOffset, assembler) {
@@ -3672,6 +5061,21 @@
 ASSEMBLER_TEST_RUN(FldrdFstrdLargeOffset, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz ip0, #0x8000 lsl 32\n"
+      "movk ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "sub r15, r15, #0x1000\n"
+      "and csp, r15, 0xfffffffffffffff0\n"
+      "fstrd v1, [r15, #4096]\n"
+      "add r15, r15, #0x1000\n"
+      "fldrd v0, [r15]\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdExtReg, assembler) {
@@ -3694,6 +5098,23 @@
 ASSEMBLER_TEST_RUN(FldrdFstrdExtReg, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz ip0, #0x8000 lsl 32\n"
+      "movk ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "movz r2, #0xfff8\n"
+      "movk r2, #0xffff lsl 16\n"
+      "fstrd v1, [r15, r2 sxtw]\n"
+      "sub r15, r15, #0x8\n"
+      "and csp, r15, 0xfffffffffffffff0\n"
+      "fldrd v0, [r15]\n"
+      "add r15, r15, #0x8\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(FldrdFstrdScaledReg, assembler) {
@@ -3714,6 +5135,22 @@
 ASSEMBLER_TEST_RUN(FldrdFstrdScaledReg, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz ip0, #0x8000 lsl 32\n"
+      "movk ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "movz r2, #0xa\n"
+      "sub r15, r15, #0x50\n"
+      "and csp, r15, 0xfffffffffffffff0\n"
+      "fstrd v1, [r15, r2 uxtx scaled]\n"
+      "fldrd v0, [r15, r2 uxtx scaled]\n"
+      "add r15, r15, #0x50\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(VinswVmovrs, assembler) {
@@ -3742,6 +5179,23 @@
   EXPECT(test != NULL);
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(174, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "movz r1, #0x2b\n"
+      "movz r2, #0x2c\n"
+      "movz r3, #0x2d\n"
+      "vinss v0[0], r0\n"
+      "vinss v0[1], r1\n"
+      "vinss v0[2], r2\n"
+      "vinss v0[3], r3\n"
+      "vmovrs r4, v0[0]\n"
+      "vmovrs r5, v0[1]\n"
+      "vmovrs r6, v0[2]\n"
+      "vmovrs r7, v0[3]\n"
+      "add r0, r4, r5\n"
+      "add r0, r0, r6\n"
+      "add r0, r0, r7\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(VinsxVmovrd, assembler) {
@@ -3762,6 +5216,15 @@
   EXPECT(test != NULL);
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(85, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r0, #0x2a\n"
+      "movz r1, #0x2b\n"
+      "vinsd v0[0], r0\n"
+      "vinsd v0[1], r1\n"
+      "vmovrd r2, v0[0]\n"
+      "vmovrd r3, v0[1]\n"
+      "add r0, r2, r3\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vnot, assembler) {
@@ -3788,6 +5251,22 @@
   EXPECT(test != NULL);
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(2, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r0, 0xfffffffe\n"
+      "mov r1, 0xffffffff\n"
+      "vinss v1[0], r1\n"
+      "vinss v1[1], r0\n"
+      "vinss v1[2], r1\n"
+      "vinss v1[3], r0\n"
+      "vnot v0, v1\n"
+      "vmovrs r2, v0[0]\n"
+      "vmovrs r3, v0[1]\n"
+      "vmovrs r4, v0[2]\n"
+      "vmovrs r5, v0[3]\n"
+      "add r0, r2, r3\n"
+      "add r0, r0, r4\n"
+      "add r0, r0, r5\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vabss, assembler) {
@@ -3816,6 +5295,21 @@
 ASSEMBLER_TEST_RUN(Vabss, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "fmovd v1, 21.000000\n"
+      "fmovd v2, -21.000000\n"
+      "fcvtsd v1, v1\n"
+      "fcvtsd v2, v2\n"
+      "veor v3, v3, v3\n"
+      "vinss v3[1], v1[0]\n"
+      "vinss v3[3], v2[0]\n"
+      "vabss v4, v3\n"
+      "vinss v5[0], v4[1]\n"
+      "vinss v6[0], v4[3]\n"
+      "fcvtds v5, v5\n"
+      "fcvtds v6, v6\n"
+      "faddd v0, v5, v6\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vabsd, assembler) {
@@ -3837,6 +5331,16 @@
 ASSEMBLER_TEST_RUN(Vabsd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "fmovd v1, 21.000000\n"
+      "fmovd v2, -21.000000\n"
+      "vinsd v3[0], v1[0]\n"
+      "vinsd v3[1], v2[0]\n"
+      "vabsd v4, v3\n"
+      "vinsd v5[0], v4[0]\n"
+      "vinsd v6[0], v4[1]\n"
+      "faddd v0, v5, v6\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vnegs, assembler) {
@@ -3864,6 +5368,23 @@
 ASSEMBLER_TEST_RUN(Vnegs, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "movz ip0, #0xc055 lsl 48\n"
+      "fmovdr v2, ip0\n"
+      "fcvtsd v1, v1\n"
+      "fcvtsd v2, v2\n"
+      "veor v3, v3, v3\n"
+      "vinss v3[1], v1[0]\n"
+      "vinss v3[3], v2[0]\n"
+      "vnegs v4, v3\n"
+      "vinss v5[0], v4[1]\n"
+      "vinss v6[0], v4[3]\n"
+      "fcvtds v5, v5\n"
+      "fcvtds v6, v6\n"
+      "faddd v0, v5, v6\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vnegd, assembler) {
@@ -3885,6 +5406,19 @@
 ASSEMBLER_TEST_RUN(Vnegd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      ""
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "movz ip0, #0xc055 lsl 48\n"
+      "fmovdr v2, ip0\n"
+      "vinsd v3[0], v1[0]\n"
+      "vinsd v3[1], v2[0]\n"
+      "vnegd v4, v3\n"
+      "vinsd v5[0], v4[0]\n"
+      "vinsd v6[0], v4[1]\n"
+      "faddd v0, v5, v6\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vadds, assembler) {
@@ -3924,6 +5458,33 @@
 ASSEMBLER_TEST_RUN(Vadds, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(12.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x0\n"
+      "fmovdr v0, ip0\n"
+      "fmovd v1, 1.000000\n"
+      "fmovd v2, 2.000000\n"
+      "fmovd v3, 3.000000\n"
+      "fcvtsd v0, v0\n"
+      "fcvtsd v1, v1\n"
+      "fcvtsd v2, v2\n"
+      "fcvtsd v3, v3\n"
+      "vinss v4[0], v0[0]\n"
+      "vinss v4[1], v1[0]\n"
+      "vinss v4[2], v2[0]\n"
+      "vinss v4[3], v3[0]\n"
+      "vadds v5, v4, v4\n"
+      "vinss v0[0], v5[0]\n"
+      "vinss v1[0], v5[1]\n"
+      "vinss v2[0], v5[2]\n"
+      "vinss v3[0], v5[3]\n"
+      "fcvtds v0, v0\n"
+      "fcvtds v1, v1\n"
+      "fcvtds v2, v2\n"
+      "fcvtds v3, v3\n"
+      "faddd v0, v0, v1\n"
+      "faddd v0, v0, v2\n"
+      "faddd v0, v0, v3\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vsubs, assembler) {
@@ -3964,6 +5525,36 @@
 ASSEMBLER_TEST_RUN(Vsubs, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(-6.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      ""
+      "movz ip0, #0x0\n"
+      "fmovdr v0, ip0\n"
+      "fmovd v1, 1.000000\n"
+      "fmovd v2, 2.000000\n"
+      "fmovd v3, 3.000000\n"
+      "movz ip0, #0x0\n"
+      "fmovdr v5, ip0\n"
+      "fcvtsd v0, v0\n"
+      "fcvtsd v1, v1\n"
+      "fcvtsd v2, v2\n"
+      "fcvtsd v3, v3\n"
+      "vinss v4[0], v0[0]\n"
+      "vinss v4[1], v1[0]\n"
+      "vinss v4[2], v2[0]\n"
+      "vinss v4[3], v3[0]\n"
+      "vsubs v5, v5, v4\n"
+      "vinss v0[0], v5[0]\n"
+      "vinss v1[0], v5[1]\n"
+      "vinss v2[0], v5[2]\n"
+      "vinss v3[0], v5[3]\n"
+      "fcvtds v0, v0\n"
+      "fcvtds v1, v1\n"
+      "fcvtds v2, v2\n"
+      "fcvtds v3, v3\n"
+      "faddd v0, v0, v1\n"
+      "faddd v0, v0, v2\n"
+      "faddd v0, v0, v3\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vmuls, assembler) {
@@ -4003,6 +5594,34 @@
 ASSEMBLER_TEST_RUN(Vmuls, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(14.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      ""
+      "movz ip0, #0x0\n"
+      "fmovdr v0, ip0\n"
+      "fmovd v1, 1.000000\n"
+      "fmovd v2, 2.000000\n"
+      "fmovd v3, 3.000000\n"
+      "fcvtsd v0, v0\n"
+      "fcvtsd v1, v1\n"
+      "fcvtsd v2, v2\n"
+      "fcvtsd v3, v3\n"
+      "vinss v4[0], v0[0]\n"
+      "vinss v4[1], v1[0]\n"
+      "vinss v4[2], v2[0]\n"
+      "vinss v4[3], v3[0]\n"
+      "vmuls v5, v4, v4\n"
+      "vinss v0[0], v5[0]\n"
+      "vinss v1[0], v5[1]\n"
+      "vinss v2[0], v5[2]\n"
+      "vinss v3[0], v5[3]\n"
+      "fcvtds v0, v0\n"
+      "fcvtds v1, v1\n"
+      "fcvtds v2, v2\n"
+      "fcvtds v3, v3\n"
+      "faddd v0, v0, v1\n"
+      "faddd v0, v0, v2\n"
+      "faddd v0, v0, v3\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vdivs, assembler) {
@@ -4042,6 +5661,34 @@
 ASSEMBLER_TEST_RUN(Vdivs, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(4.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      ""
+      "movz ip0, #0x0\n"
+      "fmovdr v0, ip0\n"
+      "fmovd v1, 1.000000\n"
+      "fmovd v2, 2.000000\n"
+      "fmovd v3, 3.000000\n"
+      "fcvtsd v0, v0\n"
+      "fcvtsd v1, v1\n"
+      "fcvtsd v2, v2\n"
+      "fcvtsd v3, v3\n"
+      "vinss v4[0], v0[0]\n"
+      "vinss v4[1], v1[0]\n"
+      "vinss v4[2], v2[0]\n"
+      "vinss v4[3], v3[0]\n"
+      "vdivs v5, v4, v4\n"
+      "vinss v0[0], v5[0]\n"
+      "vinss v1[0], v5[1]\n"
+      "vinss v2[0], v5[2]\n"
+      "vinss v3[0], v5[3]\n"
+      "fcvtds v0, v0\n"
+      "fcvtds v1, v1\n"
+      "fcvtds v2, v2\n"
+      "fcvtds v3, v3\n"
+      "faddd v0, v1, v1\n"
+      "faddd v0, v0, v2\n"
+      "faddd v0, v0, v3\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vaddd, assembler) {
@@ -4063,6 +5710,17 @@
 ASSEMBLER_TEST_RUN(Vaddd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(10.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      ""
+      "fmovd v0, 2.000000\n"
+      "fmovd v1, 3.000000\n"
+      "vinsd v4[0], v0[0]\n"
+      "vinsd v4[1], v1[0]\n"
+      "vaddd v5, v4, v4\n"
+      "vinsd v0[0], v5[0]\n"
+      "vinsd v1[0], v5[1]\n"
+      "faddd v0, v0, v1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vsubd, assembler) {
@@ -4085,6 +5743,18 @@
 ASSEMBLER_TEST_RUN(Vsubd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(-5.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "fmovd v0, 2.000000\n"
+      "fmovd v1, 3.000000\n"
+      "movz ip0, #0x0\n"
+      "fmovdr v5, ip0\n"
+      "vinsd v4[0], v0[0]\n"
+      "vinsd v4[1], v1[0]\n"
+      "vsubd v5, v5, v4\n"
+      "vinsd v0[0], v5[0]\n"
+      "vinsd v1[0], v5[1]\n"
+      "faddd v0, v0, v1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vmuld, assembler) {
@@ -4106,6 +5776,17 @@
 ASSEMBLER_TEST_RUN(Vmuld, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(13.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      ""
+      "fmovd v0, 2.000000\n"
+      "fmovd v1, 3.000000\n"
+      "vinsd v4[0], v0[0]\n"
+      "vinsd v4[1], v1[0]\n"
+      "vmuld v5, v4, v4\n"
+      "vinsd v0[0], v5[0]\n"
+      "vinsd v1[0], v5[1]\n"
+      "faddd v0, v0, v1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vdivd, assembler) {
@@ -4127,6 +5808,16 @@
 ASSEMBLER_TEST_RUN(Vdivd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(2.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "fmovd v0, 2.000000\n"
+      "fmovd v1, 3.000000\n"
+      "vinsd v4[0], v0[0]\n"
+      "vinsd v4[1], v1[0]\n"
+      "vdivd v5, v4, v4\n"
+      "vinsd v0[0], v5[0]\n"
+      "vinsd v1[0], v5[1]\n"
+      "faddd v0, v0, v1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vdupd, assembler) {
@@ -4152,6 +5843,19 @@
 ASSEMBLER_TEST_RUN(Vdupd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      ""
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "fmovd v0, 21.000000\n"
+      "vdupd v1, v0[0]\n"
+      "sub csp, csp, #0x10\n"
+      "fstrq v1, [r15, #-16]!\n"
+      "fldrd v2, [r15], #8 !\n"
+      "fldrd v3, [r15], #8 !\n"
+      "faddd v0, v2, v3\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vdups, assembler) {
@@ -4187,6 +5891,28 @@
 ASSEMBLER_TEST_RUN(Vdups, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(84.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      ""
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "fmovd v0, 21.000000\n"
+      "fcvtsd v0, v0\n"
+      "vdups v1, v0[0]\n"
+      "sub csp, csp, #0x10\n"
+      "fstrq v1, [r15, #-16]!\n"
+      "fldrs v3, [r15], #4 !\n"
+      "fldrs v2, [r15], #4 !\n"
+      "fldrs v1, [r15], #4 !\n"
+      "fldrs v0, [r15], #4 !\n"
+      "fcvtds v0, v0\n"
+      "fcvtds v1, v1\n"
+      "fcvtds v2, v2\n"
+      "fcvtds v3, v3\n"
+      "faddd v0, v1, v1\n"
+      "faddd v0, v0, v2\n"
+      "faddd v0, v0, v3\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vinsd, assembler) {
@@ -4212,6 +5938,20 @@
 ASSEMBLER_TEST_RUN(Vinsd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      ""
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v5, ip0\n"
+      "vinsd v1[1], v5[0]\n"
+      "sub csp, csp, #0x10\n"
+      "fstrq v1, [r15, #-16]!\n"
+      "fldrd v2, [r15], #8 !\n"
+      "fldrd v3, [r15], #8 !\n"
+      "fmovdd v0, v3\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vinss, assembler) {
@@ -4255,6 +5995,33 @@
 ASSEMBLER_TEST_RUN(Vinss, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "fmovd v0, 21.000000\n"
+      "fcvtsd v0, v0\n"
+      "vinss v1[3], v0[0]\n"
+      "vinss v1[1], v0[0]\n"
+      "movz ip0, #0x0\n"
+      "fmovdr v0, ip0\n"
+      "fcvtsd v0, v0\n"
+      "vinss v1[2], v0[0]\n"
+      "vinss v1[0], v0[0]\n"
+      "sub csp, csp, #0x10\n"
+      "fstrq v1, [r15, #-16]!\n"
+      "fldrs v3, [r15], #4 !\n"
+      "fldrs v2, [r15], #4 !\n"
+      "fldrs v1, [r15], #4 !\n"
+      "fldrs v0, [r15], #4 !\n"
+      "fcvtds v0, v0\n"
+      "fcvtds v1, v1\n"
+      "fcvtds v2, v2\n"
+      "fcvtds v3, v3\n"
+      "faddd v0, v0, v1\n"
+      "faddd v0, v0, v2\n"
+      "faddd v0, v0, v3\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vand, assembler) {
@@ -4290,6 +6057,26 @@
 ASSEMBLER_TEST_RUN(Vand, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "fmovd v1, 21.000000\n"
+      "mov r0, 0xffffffff\n"
+      "fmovdr v0, r0\n"
+      "vinss v0[2], v0[0]\n"
+      "fcvtsd v1, v1\n"
+      "vdups v1, v1[0]\n"
+      "vand v2, v1, v0\n"
+      "vinss v3[0], v2[0]\n"
+      "vinss v4[0], v2[1]\n"
+      "vinss v5[0], v2[2]\n"
+      "vinss v6[0], v2[3]\n"
+      "fcvtds v3, v3\n"
+      "fcvtds v4, v4\n"
+      "fcvtds v5, v5\n"
+      "fcvtds v6, v6\n"
+      "vaddd v0, v3, v4\n"
+      "vaddd v0, v0, v5\n"
+      "vaddd v0, v0, v6\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vorr, assembler) {
@@ -4326,6 +6113,27 @@
 ASSEMBLER_TEST_RUN(Vorr, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "fmovd v1, 10.500000\n"
+      "fcvtsd v1, v1\n"
+      "fmovdd v0, v1\n"
+      "vinss v0[2], v0[0]\n"
+      "veor v1, v1, v1\n"
+      "vinss v1[1], v0[0]\n"
+      "vinss v1[3], v0[0]\n"
+      "vorr v2, v1, v0\n"
+      "vinss v3[0], v2[0]\n"
+      "vinss v4[0], v2[1]\n"
+      "vinss v5[0], v2[2]\n"
+      "vinss v6[0], v2[3]\n"
+      "fcvtds v3, v3\n"
+      "fcvtds v4, v4\n"
+      "fcvtds v5, v5\n"
+      "fcvtds v6, v6\n"
+      "vaddd v0, v3, v4\n"
+      "vaddd v0, v0, v5\n"
+      "vaddd v0, v0, v6\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Veor, assembler) {
@@ -4358,6 +6166,26 @@
 ASSEMBLER_TEST_RUN(Veor, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "mov r1, 0xffffffff\n"
+      "movn r2, #0x15\n"
+      "vinss v1[0], r1\n"
+      "vinss v1[1], r2\n"
+      "vinss v1[2], r1\n"
+      "vinss v1[3], r2\n"
+      "vinss v2[0], r1\n"
+      "vinss v2[1], r1\n"
+      "vinss v2[2], r1\n"
+      "vinss v2[3], r1\n"
+      "veor v0, v1, v2\n"
+      "vmovrs r3, v0[0]\n"
+      "vmovrs r4, v0[1]\n"
+      "vmovrs r5, v0[2]\n"
+      "vmovrs r6, v0[3]\n"
+      "add r0, r3, r4\n"
+      "add r0, r0, r5\n"
+      "add r0, r0, r6\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vaddw, assembler) {
@@ -4381,6 +6209,19 @@
 ASSEMBLER_TEST_RUN(Vaddw, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(168, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r4, #0x15\n"
+      "vdups v1, r4\n"
+      "vdups v2, r4\n"
+      "vaddw v0, v1, v2\n"
+      "vmovrs r0, v0[0]\n"
+      "vmovrs r1, v0[1]\n"
+      "vmovrs r2, v0[2]\n"
+      "vmovrs r3, v0[3]\n"
+      "add r0, r0, r1\n"
+      "add r0, r0, r2\n"
+      "add r0, r0, r3\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vsubw, assembler) {
@@ -4405,6 +6246,20 @@
 ASSEMBLER_TEST_RUN(Vsubw, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(84, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r4, #0x1f\n"
+      "movz r5, #0xa\n"
+      "vdups v1, r4\n"
+      "vdups v2, r5\n"
+      "vsubw v0, v1, v2\n"
+      "vmovrs r0, v0[0]\n"
+      "vmovrs r1, v0[1]\n"
+      "vmovrs r2, v0[2]\n"
+      "vmovrs r3, v0[3]\n"
+      "add r0, r0, r1\n"
+      "add r0, r0, r2\n"
+      "add r0, r0, r3\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vaddx, assembler) {
@@ -4424,6 +6279,15 @@
 ASSEMBLER_TEST_RUN(Vaddx, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(84, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r4, #0x15\n"
+      "vdupd v1, r4\n"
+      "vdupd v2, r4\n"
+      "vaddx v0, v1, v2\n"
+      "vmovrd r0, v0[0]\n"
+      "vmovrd r1, v0[1]\n"
+      "add r0, r0, r1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vsubx, assembler) {
@@ -4444,6 +6308,16 @@
 ASSEMBLER_TEST_RUN(Vsubx, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz r4, #0x1f\n"
+      "movz r5, #0xa\n"
+      "vdupd v1, r4\n"
+      "vdupd v2, r5\n"
+      "vsubx v0, v1, v2\n"
+      "vmovrd r0, v0[0]\n"
+      "vmovrd r1, v0[1]\n"
+      "add r0, r0, r1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vceqs, assembler) {
@@ -4475,6 +6349,27 @@
 ASSEMBLER_TEST_RUN(Vceqs, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0xfffffffe, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0xc045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fcvtsd v0, v0\n"
+      "fcvtsd v1, v1\n"
+      "vdups v2, v0[0]\n"
+      "vinss v3[0], v0[0]\n"
+      "vinss v3[1], v1[0]\n"
+      "vinss v3[2], v0[0]\n"
+      "vinss v3[3], v1[0]\n"
+      "vceqs v4, v2, v3\n"
+      "vmovrs r1, v4[0]\n"
+      "vmovrs r2, v4[1]\n"
+      "vmovrs r3, v4[2]\n"
+      "vmovrs r4, v4[3]\n"
+      "addw r0, r1, r2\n"
+      "addw r0, r0, r3\n"
+      "addw r0, r0, r4\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vceqd, assembler) {
@@ -4497,6 +6392,19 @@
 ASSEMBLER_TEST_RUN(Vceqd, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0xc045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "vdupd v2, v0[0]\n"
+      "vinsd v3[0], v0[0]\n"
+      "vinsd v3[1], v1[0]\n"
+      "vceqd v4, v2, v3\n"
+      "vmovrd r1, v4[0]\n"
+      "vmovrd r2, v4[1]\n"
+      "add r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vcgts, assembler) {
@@ -4528,6 +6436,27 @@
 ASSEMBLER_TEST_RUN(Vcgts, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0xfffffffe, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0xc045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fcvtsd v0, v0\n"
+      "fcvtsd v1, v1\n"
+      "vdups v2, v0[0]\n"
+      "vinss v3[0], v0[0]\n"
+      "vinss v3[1], v1[0]\n"
+      "vinss v3[2], v0[0]\n"
+      "vinss v3[3], v1[0]\n"
+      "vcgts v4, v2, v3\n"
+      "vmovrs r1, v4[0]\n"
+      "vmovrs r2, v4[1]\n"
+      "vmovrs r3, v4[2]\n"
+      "vmovrs r4, v4[3]\n"
+      "addw r0, r1, r2\n"
+      "addw r0, r0, r3\n"
+      "addw r0, r0, r4\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vcgtd, assembler) {
@@ -4550,6 +6479,19 @@
 ASSEMBLER_TEST_RUN(Vcgtd, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0xc045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "vdupd v2, v0[0]\n"
+      "vinsd v3[0], v0[0]\n"
+      "vinsd v3[1], v1[0]\n"
+      "vcgtd v4, v2, v3\n"
+      "vmovrd r1, v4[0]\n"
+      "vmovrd r2, v4[1]\n"
+      "add r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vcges, assembler) {
@@ -4581,6 +6523,28 @@
 ASSEMBLER_TEST_RUN(Vcges, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(0xfffffffe, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0x8000 lsl 32\n"
+      "movk ip0, #0x4045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fcvtsd v0, v0\n"
+      "fcvtsd v1, v1\n"
+      "vdups v2, v0[0]\n"
+      "vinss v3[0], v0[0]\n"
+      "vinss v3[1], v1[0]\n"
+      "vinss v3[2], v0[0]\n"
+      "vinss v3[3], v1[0]\n"
+      "vcges v4, v2, v3\n"
+      "vmovrs r1, v4[0]\n"
+      "vmovrs r2, v4[1]\n"
+      "vmovrs r3, v4[2]\n"
+      "vmovrs r4, v4[3]\n"
+      "addw r0, r1, r2\n"
+      "addw r0, r0, r3\n"
+      "addw r0, r0, r4\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vcged, assembler) {
@@ -4603,6 +6567,20 @@
 ASSEMBLER_TEST_RUN(Vcged, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4045 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0x8000 lsl 32\n"
+      "movk ip0, #0x4045 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "vdupd v2, v0[0]\n"
+      "vinsd v3[0], v0[0]\n"
+      "vinsd v3[1], v1[0]\n"
+      "vcged v4, v2, v3\n"
+      "vmovrd r1, v4[0]\n"
+      "vmovrd r2, v4[1]\n"
+      "add r0, r1, r2\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vmaxs, assembler) {
@@ -4639,6 +6617,29 @@
 ASSEMBLER_TEST_RUN(Vmaxs, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "fmovd v0, 10.500000\n"
+      "fmovd v1, 10.000000\n"
+      "fcvtsd v0, v0\n"
+      "fcvtsd v1, v1\n"
+      "vdups v2, v0[0]\n"
+      "vinss v3[0], v0[0]\n"
+      "vinss v3[1], v1[0]\n"
+      "vinss v3[2], v0[0]\n"
+      "vinss v3[3], v1[0]\n"
+      "vmaxs v4, v2, v3\n"
+      "vinss v0[0], v4[0]\n"
+      "vinss v1[0], v4[1]\n"
+      "vinss v2[0], v4[2]\n"
+      "vinss v3[0], v4[3]\n"
+      "fcvtds v0, v0\n"
+      "fcvtds v1, v1\n"
+      "fcvtds v2, v2\n"
+      "fcvtds v3, v3\n"
+      "faddd v0, v0, v1\n"
+      "faddd v0, v0, v2\n"
+      "faddd v0, v0, v3\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vmaxd, assembler) {
@@ -4661,6 +6662,19 @@
 ASSEMBLER_TEST_RUN(Vmaxd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "fmovd v0, 21.000000\n"
+      "movz ip0, #0x8000 lsl 32\n"
+      "movk ip0, #0x4034 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "vdupd v2, v0[0]\n"
+      "vinsd v3[0], v0[0]\n"
+      "vinsd v3[1], v1[0]\n"
+      "vmaxd v4, v2, v3\n"
+      "vinsd v0[0], v4[0]\n"
+      "vinsd v1[0], v4[1]\n"
+      "faddd v0, v0, v1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vmins, assembler) {
@@ -4697,6 +6711,29 @@
 ASSEMBLER_TEST_RUN(Vmins, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "fmovd v0, 10.500000\n"
+      "fmovd v1, 11.000000\n"
+      "fcvtsd v0, v0\n"
+      "fcvtsd v1, v1\n"
+      "vdups v2, v0[0]\n"
+      "vinss v3[0], v0[0]\n"
+      "vinss v3[1], v1[0]\n"
+      "vinss v3[2], v0[0]\n"
+      "vinss v3[3], v1[0]\n"
+      "vmins v4, v2, v3\n"
+      "vinss v0[0], v4[0]\n"
+      "vinss v1[0], v4[1]\n"
+      "vinss v2[0], v4[2]\n"
+      "vinss v3[0], v4[3]\n"
+      "fcvtds v0, v0\n"
+      "fcvtds v1, v1\n"
+      "fcvtds v2, v2\n"
+      "fcvtds v3, v3\n"
+      "faddd v0, v0, v1\n"
+      "faddd v0, v0, v2\n"
+      "faddd v0, v0, v3\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vmind, assembler) {
@@ -4719,6 +6756,19 @@
 ASSEMBLER_TEST_RUN(Vmind, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "fmovd v0, 21.000000\n"
+      "movz ip0, #0x8000 lsl 32\n"
+      "movk ip0, #0x4035 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "vdupd v2, v0[0]\n"
+      "vinsd v3[0], v0[0]\n"
+      "vinsd v3[1], v1[0]\n"
+      "vmind v4, v2, v3\n"
+      "vinsd v0[0], v4[0]\n"
+      "vinsd v1[0], v4[1]\n"
+      "faddd v0, v0, v1\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vsqrts, assembler) {
@@ -4747,6 +6797,24 @@
 ASSEMBLER_TEST_RUN(Vsqrts, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(15.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4050 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0x8000 lsl 32\n"
+      "movk ip0, #0x4048 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fcvtsd v0, v0\n"
+      "fcvtsd v1, v1\n"
+      "veor v3, v3, v3\n"
+      "vinss v3[1], v0[0]\n"
+      "vinss v3[3], v1[0]\n"
+      "vsqrts v4, v3\n"
+      "vinss v5[0], v4[1]\n"
+      "vinss v6[0], v4[3]\n"
+      "fcvtds v5, v5\n"
+      "fcvtds v6, v6\n"
+      "faddd v0, v5, v6\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vsqrtd, assembler) {
@@ -4768,6 +6836,19 @@
 ASSEMBLER_TEST_RUN(Vsqrtd, test) {
   typedef double (*DoubleReturn)() DART_UNUSED;
   EXPECT_EQ(15.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()));
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x4050 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "movz ip0, #0x8000 lsl 32\n"
+      "movk ip0, #0x4048 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "vinsd v3[0], v0[0]\n"
+      "vinsd v3[1], v1[0]\n"
+      "vsqrtd v4, v3\n"
+      "vinsd v5[0], v4[0]\n"
+      "vinsd v6[0], v4[1]\n"
+      "faddd v0, v5, v6\n"
+      "ret\n");
 }
 
 // This is the same function as in the Simulator.
@@ -4824,6 +6905,18 @@
   typedef double (*DoubleReturn)() DART_UNUSED;
   float res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry());
   EXPECT_FLOAT_EQ(arm_recip_estimate(147.0), res, 0.0001);
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x6000 lsl 32\n"
+      "movk ip0, #0x4062 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fcvtsd v1, v1\n"
+      "vinss v2[0], v1[0]\n"
+      "vinss v2[1], v1[0]\n"
+      "vinss v2[2], v1[0]\n"
+      "vinss v2[3], v1[0]\n"
+      "vrecpes v0, v2\n"
+      "fcvtds v0, v0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vrecpss, assembler) {
@@ -4844,6 +6937,14 @@
   typedef double (*DoubleReturn)() DART_UNUSED;
   double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry());
   EXPECT_FLOAT_EQ(2.0 - 10.0 * 5.0, res, 0.0001);
+  EXPECT_DISASSEMBLY(
+      "fmovd v1, 5.000000\n"
+      "fmovd v2, 10.000000\n"
+      "fcvtsd v1, v1\n"
+      "fcvtsd v2, v2\n"
+      "vrecpss v0, v1, v2\n"
+      "fcvtds v0, v0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(VRecps, assembler) {
@@ -4874,6 +6975,31 @@
   typedef double (*DoubleReturn)() DART_UNUSED;
   double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry());
   EXPECT_FLOAT_EQ(42.0, res, 0.0001);
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x8618\n"
+      "movk ip0, #0x1861 lsl 16\n"
+      "movk ip0, #0x6186 lsl 32\n"
+      "movk ip0, #0x3fb8 lsl 48\n"
+      "fmovdr v0, ip0\n"
+      "fcvtsd v0, v0\n"
+      "vdups v1, v0[0]\n"
+      "vrecpes v2, v1\n"
+      "vrecpss v31, v1, v2\n"
+      "vmuls v2, v2, v31\n"
+      "vrecpss v31, v1, v2\n"
+      "vmuls v2, v2, v31\n"
+      "vinss v0[0], v2[0]\n"
+      "vinss v1[0], v2[1]\n"
+      "vinss v2[0], v2[2]\n"
+      "vinss v3[0], v2[3]\n"
+      "fcvtds v0, v0\n"
+      "fcvtds v1, v1\n"
+      "fcvtds v2, v2\n"
+      "fcvtds v3, v3\n"
+      "faddd v0, v0, v1\n"
+      "faddd v0, v0, v2\n"
+      "faddd v0, v0, v3\n"
+      "ret\n");
 }
 
 static float arm_reciprocal_sqrt_estimate(float a) {
@@ -4945,6 +7071,14 @@
   typedef double (*DoubleReturn)() DART_UNUSED;
   double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry());
   EXPECT_FLOAT_EQ(arm_reciprocal_sqrt_estimate(147.0), res, 0.0001);
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0x6000 lsl 32\n"
+      "movk ip0, #0x4062 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fcvtsd v1, v1\n"
+      "vrsqrtes v0, v1\n"
+      "fcvtds v0, v0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(Vrsqrtss, assembler) {
@@ -4965,6 +7099,14 @@
   typedef double (*DoubleReturn)() DART_UNUSED;
   double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry());
   EXPECT_FLOAT_EQ((3.0 - 10.0 * 5.0) / 2.0, res, 0.0001);
+  EXPECT_DISASSEMBLY(
+      "fmovd v1, 5.000000\n"
+      "fmovd v2, 10.000000\n"
+      "fcvtsd v1, v1\n"
+      "fcvtsd v2, v2\n"
+      "vrsqrts v0, v1, v2\n"
+      "fcvtds v0, v0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(ReciprocalSqrt, assembler) {
@@ -4982,6 +7124,20 @@
   typedef double (*DoubleReturn)() DART_UNUSED;
   double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry());
   EXPECT_FLOAT_EQ(1.0 / sqrt(147000.0), res, 0.0001);
+  EXPECT_DISASSEMBLY(
+      "movz ip0, #0xf1c0 lsl 32\n"
+      "movk ip0, #0x4101 lsl 48\n"
+      "fmovdr v1, ip0\n"
+      "fcvtsd v1, v1\n"
+      "vrsqrtes v0, v1\n"
+      "vmuls v31, v0, v0\n"
+      "vrsqrts v31, v1, v31\n"
+      "vmuls v0, v0, v31\n"
+      "vmuls v31, v0, v0\n"
+      "vrsqrts v31, v1, v31\n"
+      "vmuls v0, v0, v31\n"
+      "fcvtds v0, v0\n"
+      "ret\n");
 }
 
 // Called from assembler_test.cc.
@@ -5043,6 +7199,9 @@
   EXPECT_EQ(0, EXECUTE_TEST_CODE_INTPTR_INTPTR(IntPtrReturn, test->entry(), 0));
   EXPECT_EQ(0,
             EXECUTE_TEST_CODE_INTPTR_INTPTR(IntPtrReturn, test->entry(), 42));
+  EXPECT_DISASSEMBLY(
+      "andw r0, r0, 0xfffffe00\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(OrImmediate32Negative, assembler) {
@@ -5058,6 +7217,9 @@
             EXECUTE_TEST_CODE_INTPTR_INTPTR(IntPtrReturn, test->entry(), 0));
   EXPECT_EQ(0xfffffe2a,
             EXECUTE_TEST_CODE_INTPTR_INTPTR(IntPtrReturn, test->entry(), 42));
+  EXPECT_DISASSEMBLY(
+      "orrw r0, r0, 0xfffffe00\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(XorImmediate32Negative, assembler) {
@@ -5073,6 +7235,9 @@
             EXECUTE_TEST_CODE_INTPTR_INTPTR(IntPtrReturn, test->entry(), 0));
   EXPECT_EQ(0xfffffe2a,
             EXECUTE_TEST_CODE_INTPTR_INTPTR(IntPtrReturn, test->entry(), 42));
+  EXPECT_DISASSEMBLY(
+      "eorw r0, r0, 0xfffffe00\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(TestImmediate32Negative, assembler) {
@@ -5093,6 +7258,13 @@
   EXPECT_EQ(0, EXECUTE_TEST_CODE_INTPTR_INTPTR(IntPtrReturn, test->entry(), 0));
   EXPECT_EQ(0,
             EXECUTE_TEST_CODE_INTPTR_INTPTR(IntPtrReturn, test->entry(), 42));
+  EXPECT_DISASSEMBLY(
+      "tstw r0, 0xfffffe00\n"
+      "beq +12\n"
+      "movz r0, #0x1\n"
+      "ret\n"
+      "movz r0, #0x0\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(CompareImmediate32Negative, assembler) {
@@ -5114,6 +7286,13 @@
             EXECUTE_TEST_CODE_INTPTR_INTPTR(IntPtrReturn, test->entry(), -512));
   EXPECT_EQ(0,
             EXECUTE_TEST_CODE_INTPTR_INTPTR(IntPtrReturn, test->entry(), -511));
+  EXPECT_DISASSEMBLY(
+      "cmnw r0, #0x200\n"
+      "blt +12\n"
+      "movz r0, #0x0\n"
+      "ret\n"
+      "movz r0, #0x1\n"
+      "ret\n");
 }
 
 #if !defined(USING_THREAD_SANITIZER)
@@ -5138,6 +7317,20 @@
   typedef intptr_t (*StoreReleaseLoadAcquire)(intptr_t) DART_UNUSED;
   EXPECT_EQ(123, EXECUTE_TEST_CODE_INTPTR_INTPTR(StoreReleaseLoadAcquire,
                                                  test->entry(), 123));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "str r1, [r15, #-8]!\n"
+      "movz r1, #0x0\n"
+      "str r1, [r15, #-8]!\n"
+      "mov r1, r0\n"
+      "movz r0, #0x0\n"
+      "stlr r1, r15\n"
+      "ldar r0, r15\n"
+      "ldr r1, [r15], #8 !\n"
+      "ldr r1, [r15], #8 !\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 
 ASSEMBLER_TEST_GENERATE(StoreReleaseLoadAcquire1024, assembler) {
@@ -5161,6 +7354,24 @@
   typedef intptr_t (*StoreReleaseLoadAcquire1024)(intptr_t) DART_UNUSED;
   EXPECT_EQ(123, EXECUTE_TEST_CODE_INTPTR_INTPTR(StoreReleaseLoadAcquire1024,
                                                  test->entry(), 123));
+  EXPECT_DISASSEMBLY(
+      "mov r15, csp\n"
+      "sub csp, csp, #0x1000\n"
+      "str r1, [r15, #-8]!\n"
+      "movz r1, #0x0\n"
+      "str r1, [r15, #-8]!\n"
+      "mov r1, r0\n"
+      "movz r0, #0x0\n"
+      "sub r15, r15, #0x2000\n"
+      "add ip0, r15, #0x400\n"
+      "stlr r1, ip0\n"
+      "add ip1, r15, #0x400\n"
+      "ldar r0, ip1\n"
+      "add r15, r15, #0x2000\n"
+      "ldr r1, [r15], #8 !\n"
+      "ldr r1, [r15], #8 !\n"
+      "mov csp, r15\n"
+      "ret\n");
 }
 #endif
 
diff --git a/runtime/vm/compiler/assembler/disassembler_arm64.cc b/runtime/vm/compiler/assembler/disassembler_arm64.cc
index ced8987..490569d 100644
--- a/runtime/vm/compiler/assembler/disassembler_arm64.cc
+++ b/runtime/vm/compiler/assembler/disassembler_arm64.cc
@@ -244,7 +244,7 @@
         buffer_pos_ +=
             Utils::SNPrint(current_position_in_buffer(),
                            remaining_size_in_buffer(), ", #%d", imm9);
-        Print("] !");
+        Print("]!");
         break;
       }
       default: { Print("???"); }
@@ -269,13 +269,13 @@
       // rn + (imm7 << (2 + B31)), pre-index, no writeback.
       buffer_pos_ +=
           Utils::SNPrint(current_position_in_buffer(),
-                         remaining_size_in_buffer(), ", #%d ]", offset);
+                         remaining_size_in_buffer(), ", #%d]", offset);
       break;
     case 3:
       // rn + (imm7 << (2 + B31)), pre-index, writeback.
       buffer_pos_ +=
           Utils::SNPrint(current_position_in_buffer(),
-                         remaining_size_in_buffer(), ", #%d ]!", offset);
+                         remaining_size_in_buffer(), ", #%d]!", offset);
       break;
     default:
       Print(", ???]");
@@ -453,7 +453,7 @@
       if (shift != 0) {
         buffer_pos_ +=
             Utils::SNPrint(current_position_in_buffer(),
-                           remaining_size_in_buffer(), "lsl %d", shift);
+                           remaining_size_in_buffer(), " lsl %d", shift);
       }
       return 2;
     }
@@ -505,7 +505,7 @@
         }
         buffer_pos_ +=
             Utils::SNPrint(current_position_in_buffer(),
-                           remaining_size_in_buffer(), "0x%" Px64, imm);
+                           remaining_size_in_buffer(), "#0x%" Px64, imm);
         return ret;
       } else {
         ASSERT(STRING_STARTS_WITH(format, "imm"));
@@ -631,7 +631,8 @@
             sz_str = "w";
             break;
           case 3:
-            sz_str = "x";
+            // 64-bit width is most commonly used, no need to print "x".
+            sz_str = "";
             break;
           default:
             sz_str = "?";
@@ -683,13 +684,13 @@
 void ARM64Decoder::DecodeMoveWide(Instr* instr) {
   switch (instr->Bits(29, 2)) {
     case 0:
-      Format(instr, "movn'sf 'rd, 'imm16 'hw");
+      Format(instr, "movn'sf 'rd, 'imm16'hw");
       break;
     case 2:
-      Format(instr, "movz'sf 'rd, 'imm16 'hw");
+      Format(instr, "movz'sf 'rd, 'imm16'hw");
       break;
     case 3:
-      Format(instr, "movk'sf 'rd, 'imm16 'hw");
+      Format(instr, "movk'sf 'rd, 'imm16'hw");
       break;
     default:
       Unknown(instr);
@@ -740,11 +741,8 @@
 }
 
 void ARM64Decoder::DecodeLoadStoreExclusive(Instr* instr) {
-  if (instr->Bit(21) != 0 || instr->Bit(23) != instr->Bit(15)) {
-    Unknown(instr);
-  }
-  const int32_t size = instr->Bits(30, 2);
-  if (size != 3) {
+  if (instr->Bit(32) != 1 || instr->Bit(21) != 0 ||
+      instr->Bit(23) != instr->Bit(15)) {
     Unknown(instr);
   }
 
@@ -754,16 +752,16 @@
   if (is_load) {
     const bool is_load_acquire = !is_exclusive && is_ordered;
     if (is_load_acquire) {
-      Format(instr, "ldar 'rt, 'rn");
+      Format(instr, "ldar'sz 'rt, 'rn");
     } else {
-      Format(instr, "ldxr 'rt, 'rn");
+      Format(instr, "ldxr'sz 'rt, 'rn");
     }
   } else {
     const bool is_store_release = !is_exclusive && is_ordered;
     if (is_store_release) {
-      Format(instr, "stlr 'rt, 'rn");
+      Format(instr, "stlr'sz 'rt, 'rn");
     } else {
-      Format(instr, "stxr 'rs, 'rt, 'rn");
+      Format(instr, "stxr'sz 'rs, 'rt, 'rn");
     }
   }
 }
@@ -772,22 +770,22 @@
   switch (instr->Bit(30)) {
     case 0: {
       if ((instr->RdField() == R31) && (instr->SField() == 1)) {
-        Format(instr, "cmni'sf 'rn, 'imm12s");
+        Format(instr, "cmn'sf 'rn, 'imm12s");
       } else {
         if (((instr->RdField() == R31) || (instr->RnField() == R31)) &&
             (instr->Imm12Field() == 0) && (instr->Bit(29) == 0)) {
           Format(instr, "mov'sf 'rd, 'rn");
         } else {
-          Format(instr, "addi'sf's 'rd, 'rn, 'imm12s");
+          Format(instr, "add'sf's 'rd, 'rn, 'imm12s");
         }
       }
       break;
     }
     case 1: {
       if ((instr->RdField() == R31) && (instr->SField() == 1)) {
-        Format(instr, "cmpi'sf 'rn, 'imm12s");
+        Format(instr, "cmp'sf 'rn, 'imm12s");
       } else {
-        Format(instr, "subi'sf's 'rd, 'rn, 'imm12s");
+        Format(instr, "sub'sf's 'rd, 'rn, 'imm12s");
       }
       break;
     }
@@ -856,21 +854,25 @@
   int op = instr->Bits(29, 2);
   switch (op) {
     case 0:
-      Format(instr, "andi'sf 'rd, 'rn, 'bitimm");
+      Format(instr, "and'sf 'rd, 'rn, 'bitimm");
       break;
     case 1: {
       if (instr->RnField() == R31) {
         Format(instr, "mov'sf 'rd, 'bitimm");
       } else {
-        Format(instr, "orri'sf 'rd, 'rn, 'bitimm");
+        Format(instr, "orr'sf 'rd, 'rn, 'bitimm");
       }
       break;
     }
     case 2:
-      Format(instr, "eori'sf 'rd, 'rn, 'bitimm");
+      Format(instr, "eor'sf 'rd, 'rn, 'bitimm");
       break;
     case 3:
-      Format(instr, "andi'sfs 'rd, 'rn, 'bitimm");
+      if (instr->RdField() == R31) {
+        Format(instr, "tst'sf 'rn, 'bitimm");
+      } else {
+        Format(instr, "and'sfs 'rd, 'rn, 'bitimm");
+      }
       break;
     default:
       Unknown(instr);
@@ -948,7 +950,11 @@
         Format(instr, "blr 'rn");
         break;
       case 2:
-        Format(instr, "ret 'rn");
+        if (instr->RnField() == LINK_REGISTER) {
+          Format(instr, "ret");
+        } else {
+          Format(instr, "ret 'rn");
+        }
         break;
       default:
         Unknown(instr);
@@ -1040,7 +1046,11 @@
       if ((instr->RdField() == R31) && (instr->SFField())) {
         Format(instr, "cmp'sf 'rn, 'shift_op");
       } else {
-        Format(instr, "sub'sf's 'rd, 'rn, 'shift_op");
+        if (instr->RnField() == R31) {
+          Format(instr, "neg'sf's 'rd, 'shift_op");
+        } else {
+          Format(instr, "sub'sf's 'rd, 'rn, 'shift_op");
+        }
       }
       break;
     }
@@ -1116,6 +1126,9 @@
 
   const int op = instr->Bits(10, 10);
   switch (op) {
+    case 0:
+      Format(instr, "rbit'sf 'rd, 'rn");
+      break;
     case 4:
       Format(instr, "clz'sf 'rd, 'rn");
       break;
@@ -1208,24 +1221,24 @@
   bool non_select =
       (instr->RnField() == instr->RmField()) && ((cond & 0xe) != 0xe);
   if ((instr->Bits(29, 2) == 0) && (instr->Bits(10, 2) == 0)) {
-    Format(instr, "mov'sf'cond 'rd, 'rn, 'rm");
+    Format(instr, "csel'sf 'rd, 'rn, 'rm, 'cond");
   } else if ((instr->Bits(29, 2) == 0) && (instr->Bits(10, 2) == 1)) {
     if (non_select) {
-      Format(instr, "csinc'sf'cond 'rd, 'rn, 'rm");
+      Format(instr, "csinc'sf 'rd, 'rn, 'rm, 'cond");
     } else {
-      Format(instr, "cinc'sf'condinverted 'rd, 'rn");
+      Format(instr, "cinc'sf 'rd, 'rn, 'condinverted");
     }
   } else if ((instr->Bits(29, 2) == 2) && (instr->Bits(10, 2) == 0)) {
     if (non_select) {
-      Format(instr, "cinv'sf'condinverted 'rd, 'rn");
+      Format(instr, "cinv'sf 'rd, 'rn, 'condinverted");
     } else {
-      Format(instr, "csinv'sf'cond 'rd, 'rn, 'rm");
+      Format(instr, "csinv'sf 'rd, 'rn, 'rm, 'cond");
     }
   } else if ((instr->Bits(29, 2) == 2) && (instr->Bits(10, 2) == 1)) {
     if (non_select) {
-      Format(instr, "cneg'sf'condinverted 'rd, 'rn");
+      Format(instr, "cneg'sf 'rd, 'rn, 'condinverted");
     } else {
-      Format(instr, "csneg'sf'cond 'rd, 'rn, 'rm");
+      Format(instr, "csneg'sf 'rd, 'rn, 'rm, 'cond");
     }
   } else {
     Unknown(instr);
diff --git a/tools/VERSION b/tools/VERSION
index 640defa..07ad55c 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 16
 PATCH 0
-PRERELEASE 109
+PRERELEASE 110
 PRERELEASE_PATCH 0
\ No newline at end of file