diff --git a/CHANGELOG.md b/CHANGELOG.md
index e6e8fc7..291fc7c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -35,6 +35,18 @@
 * Fixed `unawaited_futures` to handle `Future` subtypes.
 * New lint: `avoid_type_to_string`.
 
+## 2.10.1 - 2020-10-06
+
+This is a patch release that fixes the following issues:
+* crashes when developing Flutter applications (issue [#43464][]).
+* non-deterministic incorrect program behaviour and/or crashes (issue
+  [flutter/flutter#66672][]).
+* uncaught TypeErrors in DDC (issue [#43661][]).
+
+[#43464]: https://github.com/dart-lang/sdk/issues/43464
+[flutter/flutter#66672]: https://github.com/flutter/flutter/issues/66672
+[#43661]: https://github.com/dart-lang/sdk/issues/43661
+
 ## 2.10.0 - 2020-09-28
 
 ### Core libraries
diff --git a/pkg/front_end/lib/src/api_prototype/experimental_flags_generated.dart b/pkg/front_end/lib/src/api_prototype/experimental_flags_generated.dart
index 340d7da..c3b0dc7 100644
--- a/pkg/front_end/lib/src/api_prototype/experimental_flags_generated.dart
+++ b/pkg/front_end/lib/src/api_prototype/experimental_flags_generated.dart
@@ -178,12 +178,21 @@
   "flutter_goldens_client": {
     ExperimentalFlag.nonNullable,
   },
+  "http": {
+    ExperimentalFlag.nonNullable,
+  },
+  "http_parser": {
+    ExperimentalFlag.nonNullable,
+  },
   "intl": {
     ExperimentalFlag.nonNullable,
   },
   "js": {
     ExperimentalFlag.nonNullable,
   },
+  "logging": {
+    ExperimentalFlag.nonNullable,
+  },
   "matcher": {
     ExperimentalFlag.nonNullable,
   },
diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
index d799e39..8618dbe 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
@@ -2549,6 +2549,9 @@
 
   bool isSubtype(Constant constant, DartType type, SubtypeCheckMode mode) {
     DartType constantType = constant.getType(_staticTypeContext);
+    if (mode == SubtypeCheckMode.ignoringNullabilities) {
+      constantType = rawLegacyErasure(coreTypes, constantType) ?? constantType;
+    }
     bool result = typeEnvironment.isSubtypeOf(constantType, type, mode);
     if (targetingJavaScript && !result) {
       if (constantType is InterfaceType &&
diff --git a/pkg/front_end/test/fasta/types/shared_type_tests.dart b/pkg/front_end/test/fasta/types/shared_type_tests.dart
index 37a43e8..fa1d750 100644
--- a/pkg/front_end/test/fasta/types/shared_type_tests.dart
+++ b/pkg/front_end/test/fasta/types/shared_type_tests.dart
@@ -696,7 +696,7 @@
     // Tests for bottom and top types.
     isSubtype('Null', 'Null');
     isNotSubtype('Null', 'bottom');
-    isNotSubtype('Null', 'Never');
+    isObliviousSubtype('Null', 'Never');
     isSubtype('bottom', 'Null');
     isSubtype('bottom', 'bottom');
     isSubtype('bottom', 'Never');
@@ -889,7 +889,7 @@
     isSubtype('Never', 'Id<Object>');
     isSubtype('Never', 'Id<Never>');
     isSubtype('Id<Never>', 'Never');
-    isNotSubtype('Null', 'Id<Never>');
+    isObliviousSubtype('Null', 'Id<Never>');
     isSubtype('Id<Never>', 'Null');
     isNotSubtype('Id<Object>', 'Never');
     isSubtype('Id<int>', 'num');
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index 17ed18c..16c406d 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -851,6 +851,7 @@
 r'\u
 r'\v
 r0i
+r0j
 r1i
 r2i
 ra
@@ -1309,6 +1310,7 @@
 xdfff
 xef
 xi
+xj
 xk
 xm
 xn
@@ -1328,6 +1330,7 @@
 yaml
 yb
 yet
+yi
 yielding
 yields
 yn
diff --git a/pkg/front_end/test/spell_checking_list_tests.txt b/pkg/front_end/test/spell_checking_list_tests.txt
index eaf2af5..bef5e7f 100644
--- a/pkg/front_end/test/spell_checking_list_tests.txt
+++ b/pkg/front_end/test/spell_checking_list_tests.txt
@@ -216,6 +216,7 @@
 eoo
 epoch
 erase
+erased
 err
 esc
 everytime
@@ -440,9 +441,12 @@
 nonexisting
 noo
 numerator
+ob
+obool
 observable
 oh
 okay
+ol
 onull
 ooo
 operate
@@ -453,6 +457,7 @@
 out2
 outbound
 overlay
+ox
 pack
 paging
 paint
@@ -679,3 +684,4 @@
 y's
 year
 yxxx
+yy
diff --git a/pkg/front_end/testcases/nnbd/const_is.dart b/pkg/front_end/testcases/nnbd/const_is.dart
new file mode 100644
index 0000000..ccafc28
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd/const_is.dart
@@ -0,0 +1,181 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// Tests derived from co19/Language/Types/Function_Types/subtype_named_args_t04
+// and language/nnbd/subtyping/function_type_required_params_test
+
+bool inStrongMode = <int?>[] is! List<int>;
+
+int f({required int i}) {
+  return i + 1;
+}
+
+int g({int i = 1}) {
+  return i + 1;
+}
+
+typedef int fType({required int i});
+typedef int gType({int i});
+typedef int bigType(
+    {required int i1,
+    required int i2,
+    required int i3,
+    required int i4,
+    required int i5,
+    required int i6,
+    required int i7,
+    required int i8,
+    required int i9,
+    required int i10,
+    required int i11,
+    required int i12,
+    required int i13,
+    required int i14,
+    required int i15,
+    required int i16,
+    required int i17,
+    required int i18,
+    required int i19,
+    required int i20,
+    required int i21,
+    required int i22,
+    required int i23,
+    required int i24,
+    required int i25,
+    required int i26,
+    required int i27,
+    required int i28,
+    required int i29,
+    required int i30,
+    required int i31,
+    required int i32,
+    required int i33,
+    required int i34,
+    required int i35,
+    required int i36,
+    required int i37,
+    required int i38,
+    required int i39,
+    required int i40,
+    required int i41,
+    required int i42,
+    required int i43,
+    required int i44,
+    required int i45,
+    required int i46,
+    required int i47,
+    required int i48,
+    required int i49,
+    required int i50,
+    required int i51,
+    required int i52,
+    required int i53,
+    required int i54,
+    required int i55,
+    required int i56,
+    required int i57,
+    required int i58,
+    required int i59,
+    required int i60,
+    required int i61,
+    required int i62,
+    required int i63,
+    required int i64,
+    required int i65,
+    required int i66,
+    required int i67,
+    required int i68,
+    required int i69,
+    required int i70});
+
+class A {}
+
+class A1 {}
+
+class A2 {}
+
+class B implements A, A1, A2 {}
+
+class C implements B {}
+
+class D implements C {}
+
+typedef B func(Object o);
+typedef B t1(int i, B b, Map<int, num> m, var x,
+    {required var ox,
+    required B ob,
+    required List<num> ol,
+    required bool obool});
+
+B f1(int i, B b, Map<int, num> m, var x,
+        {required extraParam,
+        required bool obool,
+        required var ox,
+        required D ob,
+        required List<num>? ol}) =>
+    new B();
+D f2(int i, D b, Map<int, int> m, func x,
+        {required func ox,
+        required D ob,
+        required List<int> ol,
+        required bool obool}) =>
+    new D();
+C f3(num i, A b, Map<Object, Object> m, var x,
+        {required var ox,
+        required extraParam,
+        required A2 ob,
+        required List ol,
+        required Object obool}) =>
+    new C();
+C f4(num i, A b, Map<Object, Object> m, var x,
+        {required var ox,
+        required A2 ob,
+        required List ol,
+        required bool obool,
+        required A xx,
+        required B yy}) =>
+    new C();
+C f5(int i, A b, Map<Object, Object> m, var x,
+        {required ox, required B ob, required List ol, required obool}) =>
+    new C();
+
+const f_is_fType = f is fType;
+const f_is_gType = f is gType;
+const g_is_fType = g is fType;
+const g_is_gType = g is gType;
+const f_is_bigType = f is bigType;
+
+const f1_is_t1 = f1 is t1;
+const f2_is_t1 = f2 is t1;
+const f3_is_t1 = f3 is t1;
+const f4_is_t1 = f4 is t1;
+const f5_is_t1 = f5 is t1;
+
+main() {
+  expect(true, f_is_fType);
+  expect(f is fType, f_is_fType);
+  expect(!inStrongMode, f_is_gType);
+  expect(f is gType, f_is_gType);
+  expect(true, g_is_fType);
+  expect(g is fType, g_is_fType);
+  expect(true, g_is_gType);
+  expect(g is gType, g_is_gType);
+  expect(false, f_is_bigType);
+  expect(f is bigType, f_is_bigType);
+
+  expect(false, f1_is_t1);
+  expect(f1 is t1, f1_is_t1);
+  expect(false, f2_is_t1);
+  expect(f2 is t1, f2_is_t1);
+  expect(!inStrongMode, f3_is_t1);
+  expect(f3 is t1, f3_is_t1);
+  expect(!inStrongMode, f4_is_t1);
+  expect(f4 is t1, f4_is_t1);
+  expect(true, f5_is_t1);
+  expect(f5 is t1, f5_is_t1);
+}
+
+expect(expected, actual) {
+  if (expected != actual) throw "Expected $expected, actual $actual";
+}
diff --git a/pkg/front_end/testcases/nnbd/const_is.dart.outline.expect b/pkg/front_end/testcases/nnbd/const_is.dart.outline.expect
new file mode 100644
index 0000000..46bacdc
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd/const_is.dart.outline.expect
@@ -0,0 +1,76 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef fType = ({required i: core::int}) → core::int;
+typedef gType = ({i: core::int}) → core::int;
+typedef bigType = ({required i1: core::int, required i10: core::int, required i11: core::int, required i12: core::int, required i13: core::int, required i14: core::int, required i15: core::int, required i16: core::int, required i17: core::int, required i18: core::int, required i19: core::int, required i2: core::int, required i20: core::int, required i21: core::int, required i22: core::int, required i23: core::int, required i24: core::int, required i25: core::int, required i26: core::int, required i27: core::int, required i28: core::int, required i29: core::int, required i3: core::int, required i30: core::int, required i31: core::int, required i32: core::int, required i33: core::int, required i34: core::int, required i35: core::int, required i36: core::int, required i37: core::int, required i38: core::int, required i39: core::int, required i4: core::int, required i40: core::int, required i41: core::int, required i42: core::int, required i43: core::int, required i44: core::int, required i45: core::int, required i46: core::int, required i47: core::int, required i48: core::int, required i49: core::int, required i5: core::int, required i50: core::int, required i51: core::int, required i52: core::int, required i53: core::int, required i54: core::int, required i55: core::int, required i56: core::int, required i57: core::int, required i58: core::int, required i59: core::int, required i6: core::int, required i60: core::int, required i61: core::int, required i62: core::int, required i63: core::int, required i64: core::int, required i65: core::int, required i66: core::int, required i67: core::int, required i68: core::int, required i69: core::int, required i7: core::int, required i70: core::int, required i8: core::int, required i9: core::int}) → core::int;
+typedef func = (core::Object) → self::B;
+typedef t1 = (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B;
+class A extends core::Object {
+  synthetic constructor •() → self::A
+    ;
+}
+class A1 extends core::Object {
+  synthetic constructor •() → self::A1
+    ;
+}
+class A2 extends core::Object {
+  synthetic constructor •() → self::A2
+    ;
+}
+class B extends core::Object implements self::A, self::A1, self::A2 {
+  synthetic constructor •() → self::B
+    ;
+}
+class C extends core::Object implements self::B {
+  synthetic constructor •() → self::C
+    ;
+}
+class D extends core::Object implements self::C {
+  synthetic constructor •() → self::D
+    ;
+}
+static field core::bool inStrongMode;
+static const field core::bool f_is_fType = self::f is{ForNonNullableByDefault} ({required i: core::int}) → core::int;
+static const field core::bool f_is_gType = self::f is{ForNonNullableByDefault} ({i: core::int}) → core::int;
+static const field core::bool g_is_fType = self::g is{ForNonNullableByDefault} ({required i: core::int}) → core::int;
+static const field core::bool g_is_gType = self::g is{ForNonNullableByDefault} ({i: core::int}) → core::int;
+static const field core::bool f_is_bigType = self::f is{ForNonNullableByDefault} ({required i1: core::int, required i10: core::int, required i11: core::int, required i12: core::int, required i13: core::int, required i14: core::int, required i15: core::int, required i16: core::int, required i17: core::int, required i18: core::int, required i19: core::int, required i2: core::int, required i20: core::int, required i21: core::int, required i22: core::int, required i23: core::int, required i24: core::int, required i25: core::int, required i26: core::int, required i27: core::int, required i28: core::int, required i29: core::int, required i3: core::int, required i30: core::int, required i31: core::int, required i32: core::int, required i33: core::int, required i34: core::int, required i35: core::int, required i36: core::int, required i37: core::int, required i38: core::int, required i39: core::int, required i4: core::int, required i40: core::int, required i41: core::int, required i42: core::int, required i43: core::int, required i44: core::int, required i45: core::int, required i46: core::int, required i47: core::int, required i48: core::int, required i49: core::int, required i5: core::int, required i50: core::int, required i51: core::int, required i52: core::int, required i53: core::int, required i54: core::int, required i55: core::int, required i56: core::int, required i57: core::int, required i58: core::int, required i59: core::int, required i6: core::int, required i60: core::int, required i61: core::int, required i62: core::int, required i63: core::int, required i64: core::int, required i65: core::int, required i66: core::int, required i67: core::int, required i68: core::int, required i69: core::int, required i7: core::int, required i70: core::int, required i8: core::int, required i9: core::int}) → core::int;
+static const field core::bool f1_is_t1 = self::f1 is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B;
+static const field core::bool f2_is_t1 = self::f2 is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B;
+static const field core::bool f3_is_t1 = self::f3 is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B;
+static const field core::bool f4_is_t1 = self::f4 is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B;
+static const field core::bool f5_is_t1 = self::f5 is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B;
+static method f({required core::int i}) → core::int
+  ;
+static method g({core::int i}) → core::int
+  ;
+static method f1(core::int i, self::B b, core::Map<core::int, core::num> m, dynamic x, {required dynamic extraParam, required core::bool obool, required dynamic ox, required self::D ob, required core::List<core::num>? ol}) → self::B
+  ;
+static method f2(core::int i, self::D b, core::Map<core::int, core::int> m, (core::Object) → self::B x, {required (core::Object) → self::B ox, required self::D ob, required core::List<core::int> ol, required core::bool obool}) → self::D
+  ;
+static method f3(core::num i, self::A b, core::Map<core::Object, core::Object> m, dynamic x, {required dynamic ox, required dynamic extraParam, required self::A2 ob, required core::List<dynamic> ol, required core::Object obool}) → self::C
+  ;
+static method f4(core::num i, self::A b, core::Map<core::Object, core::Object> m, dynamic x, {required dynamic ox, required self::A2 ob, required core::List<dynamic> ol, required core::bool obool, required self::A xx, required self::B yy}) → self::C
+  ;
+static method f5(core::int i, self::A b, core::Map<core::Object, core::Object> m, dynamic x, {required dynamic ox, required self::B ob, required core::List<dynamic> ol, required dynamic obool}) → self::C
+  ;
+static method main() → dynamic
+  ;
+static method expect(dynamic expected, dynamic actual) → dynamic
+  ;
+
+
+Extra constant evaluation status:
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:143:22 -> BoolConstant(true)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:144:22 -> BoolConstant(false)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:145:22 -> BoolConstant(true)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:146:22 -> BoolConstant(true)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:147:24 -> BoolConstant(false)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:149:21 -> BoolConstant(false)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:150:21 -> BoolConstant(false)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:151:21 -> BoolConstant(false)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:152:21 -> BoolConstant(false)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:153:21 -> BoolConstant(true)
+Extra constant evaluation: evaluated: 10, effectively constant: 10
diff --git a/pkg/front_end/testcases/nnbd/const_is.dart.strong.expect b/pkg/front_end/testcases/nnbd/const_is.dart.strong.expect
new file mode 100644
index 0000000..ecdde5d
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd/const_is.dart.strong.expect
@@ -0,0 +1,106 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef fType = ({required i: core::int}) → core::int;
+typedef gType = ({i: core::int}) → core::int;
+typedef bigType = ({required i1: core::int, required i10: core::int, required i11: core::int, required i12: core::int, required i13: core::int, required i14: core::int, required i15: core::int, required i16: core::int, required i17: core::int, required i18: core::int, required i19: core::int, required i2: core::int, required i20: core::int, required i21: core::int, required i22: core::int, required i23: core::int, required i24: core::int, required i25: core::int, required i26: core::int, required i27: core::int, required i28: core::int, required i29: core::int, required i3: core::int, required i30: core::int, required i31: core::int, required i32: core::int, required i33: core::int, required i34: core::int, required i35: core::int, required i36: core::int, required i37: core::int, required i38: core::int, required i39: core::int, required i4: core::int, required i40: core::int, required i41: core::int, required i42: core::int, required i43: core::int, required i44: core::int, required i45: core::int, required i46: core::int, required i47: core::int, required i48: core::int, required i49: core::int, required i5: core::int, required i50: core::int, required i51: core::int, required i52: core::int, required i53: core::int, required i54: core::int, required i55: core::int, required i56: core::int, required i57: core::int, required i58: core::int, required i59: core::int, required i6: core::int, required i60: core::int, required i61: core::int, required i62: core::int, required i63: core::int, required i64: core::int, required i65: core::int, required i66: core::int, required i67: core::int, required i68: core::int, required i69: core::int, required i7: core::int, required i70: core::int, required i8: core::int, required i9: core::int}) → core::int;
+typedef func = (core::Object) → self::B;
+typedef t1 = (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B;
+class A extends core::Object {
+  synthetic constructor •() → self::A
+    : super core::Object::•()
+    ;
+}
+class A1 extends core::Object {
+  synthetic constructor •() → self::A1
+    : super core::Object::•()
+    ;
+}
+class A2 extends core::Object {
+  synthetic constructor •() → self::A2
+    : super core::Object::•()
+    ;
+}
+class B extends core::Object implements self::A, self::A1, self::A2 {
+  synthetic constructor •() → self::B
+    : super core::Object::•()
+    ;
+}
+class C extends core::Object implements self::B {
+  synthetic constructor •() → self::C
+    : super core::Object::•()
+    ;
+}
+class D extends core::Object implements self::C {
+  synthetic constructor •() → self::D
+    : super core::Object::•()
+    ;
+}
+static field core::bool inStrongMode = !(<core::int?>[] is{ForNonNullableByDefault} core::List<core::int>);
+static const field core::bool f_is_fType = #C1;
+static const field core::bool f_is_gType = #C2;
+static const field core::bool g_is_fType = #C1;
+static const field core::bool g_is_gType = #C1;
+static const field core::bool f_is_bigType = #C2;
+static const field core::bool f1_is_t1 = #C2;
+static const field core::bool f2_is_t1 = #C2;
+static const field core::bool f3_is_t1 = #C2;
+static const field core::bool f4_is_t1 = #C2;
+static const field core::bool f5_is_t1 = #C1;
+static method f({required core::int i = #C3}) → core::int {
+  return i.{core::num::+}(1);
+}
+static method g({core::int i = #C4}) → core::int {
+  return i.{core::num::+}(1);
+}
+static method f1(core::int i, self::B b, core::Map<core::int, core::num> m, dynamic x, {required dynamic extraParam = #C3, required core::bool obool = #C3, required dynamic ox = #C3, required self::D ob = #C3, required core::List<core::num>? ol = #C3}) → self::B
+  return new self::B::•();
+static method f2(core::int i, self::D b, core::Map<core::int, core::int> m, (core::Object) → self::B x, {required (core::Object) → self::B ox = #C3, required self::D ob = #C3, required core::List<core::int> ol = #C3, required core::bool obool = #C3}) → self::D
+  return new self::D::•();
+static method f3(core::num i, self::A b, core::Map<core::Object, core::Object> m, dynamic x, {required dynamic ox = #C3, required dynamic extraParam = #C3, required self::A2 ob = #C3, required core::List<dynamic> ol = #C3, required core::Object obool = #C3}) → self::C
+  return new self::C::•();
+static method f4(core::num i, self::A b, core::Map<core::Object, core::Object> m, dynamic x, {required dynamic ox = #C3, required self::A2 ob = #C3, required core::List<dynamic> ol = #C3, required core::bool obool = #C3, required self::A xx = #C3, required self::B yy = #C3}) → self::C
+  return new self::C::•();
+static method f5(core::int i, self::A b, core::Map<core::Object, core::Object> m, dynamic x, {required dynamic ox = #C3, required self::B ob = #C3, required core::List<dynamic> ol = #C3, required dynamic obool = #C3}) → self::C
+  return new self::C::•();
+static method main() → dynamic {
+  self::expect(true, #C1);
+  self::expect((#C5) is{ForNonNullableByDefault} ({required i: core::int}) → core::int, #C1);
+  self::expect(!self::inStrongMode, #C2);
+  self::expect((#C5) is{ForNonNullableByDefault} ({i: core::int}) → core::int, #C2);
+  self::expect(true, #C1);
+  self::expect((#C6) is{ForNonNullableByDefault} ({required i: core::int}) → core::int, #C1);
+  self::expect(true, #C1);
+  self::expect((#C6) is{ForNonNullableByDefault} ({i: core::int}) → core::int, #C1);
+  self::expect(false, #C2);
+  self::expect((#C5) is{ForNonNullableByDefault} ({required i1: core::int, required i10: core::int, required i11: core::int, required i12: core::int, required i13: core::int, required i14: core::int, required i15: core::int, required i16: core::int, required i17: core::int, required i18: core::int, required i19: core::int, required i2: core::int, required i20: core::int, required i21: core::int, required i22: core::int, required i23: core::int, required i24: core::int, required i25: core::int, required i26: core::int, required i27: core::int, required i28: core::int, required i29: core::int, required i3: core::int, required i30: core::int, required i31: core::int, required i32: core::int, required i33: core::int, required i34: core::int, required i35: core::int, required i36: core::int, required i37: core::int, required i38: core::int, required i39: core::int, required i4: core::int, required i40: core::int, required i41: core::int, required i42: core::int, required i43: core::int, required i44: core::int, required i45: core::int, required i46: core::int, required i47: core::int, required i48: core::int, required i49: core::int, required i5: core::int, required i50: core::int, required i51: core::int, required i52: core::int, required i53: core::int, required i54: core::int, required i55: core::int, required i56: core::int, required i57: core::int, required i58: core::int, required i59: core::int, required i6: core::int, required i60: core::int, required i61: core::int, required i62: core::int, required i63: core::int, required i64: core::int, required i65: core::int, required i66: core::int, required i67: core::int, required i68: core::int, required i69: core::int, required i7: core::int, required i70: core::int, required i8: core::int, required i9: core::int}) → core::int, #C2);
+  self::expect(false, #C2);
+  self::expect((#C7) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C2);
+  self::expect(false, #C2);
+  self::expect((#C8) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C2);
+  self::expect(!self::inStrongMode, #C2);
+  self::expect((#C9) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C2);
+  self::expect(!self::inStrongMode, #C2);
+  self::expect((#C10) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C2);
+  self::expect(true, #C1);
+  self::expect((#C11) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C1);
+}
+static method expect(dynamic expected, dynamic actual) → dynamic {
+  if(!expected.{core::Object::==}(actual))
+    throw "Expected ${expected}, actual ${actual}";
+}
+
+constants  {
+  #C1 = true
+  #C2 = false
+  #C3 = null
+  #C4 = 1
+  #C5 = tearoff self::f
+  #C6 = tearoff self::g
+  #C7 = tearoff self::f1
+  #C8 = tearoff self::f2
+  #C9 = tearoff self::f3
+  #C10 = tearoff self::f4
+  #C11 = tearoff self::f5
+}
diff --git a/pkg/front_end/testcases/nnbd/const_is.dart.strong.transformed.expect b/pkg/front_end/testcases/nnbd/const_is.dart.strong.transformed.expect
new file mode 100644
index 0000000..1ba909d
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd/const_is.dart.strong.transformed.expect
@@ -0,0 +1,119 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef fType = ({required i: core::int}) → core::int;
+typedef gType = ({i: core::int}) → core::int;
+typedef bigType = ({required i1: core::int, required i10: core::int, required i11: core::int, required i12: core::int, required i13: core::int, required i14: core::int, required i15: core::int, required i16: core::int, required i17: core::int, required i18: core::int, required i19: core::int, required i2: core::int, required i20: core::int, required i21: core::int, required i22: core::int, required i23: core::int, required i24: core::int, required i25: core::int, required i26: core::int, required i27: core::int, required i28: core::int, required i29: core::int, required i3: core::int, required i30: core::int, required i31: core::int, required i32: core::int, required i33: core::int, required i34: core::int, required i35: core::int, required i36: core::int, required i37: core::int, required i38: core::int, required i39: core::int, required i4: core::int, required i40: core::int, required i41: core::int, required i42: core::int, required i43: core::int, required i44: core::int, required i45: core::int, required i46: core::int, required i47: core::int, required i48: core::int, required i49: core::int, required i5: core::int, required i50: core::int, required i51: core::int, required i52: core::int, required i53: core::int, required i54: core::int, required i55: core::int, required i56: core::int, required i57: core::int, required i58: core::int, required i59: core::int, required i6: core::int, required i60: core::int, required i61: core::int, required i62: core::int, required i63: core::int, required i64: core::int, required i65: core::int, required i66: core::int, required i67: core::int, required i68: core::int, required i69: core::int, required i7: core::int, required i70: core::int, required i8: core::int, required i9: core::int}) → core::int;
+typedef func = (core::Object) → self::B;
+typedef t1 = (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B;
+class A extends core::Object {
+  synthetic constructor •() → self::A
+    : super core::Object::•()
+    ;
+}
+class A1 extends core::Object {
+  synthetic constructor •() → self::A1
+    : super core::Object::•()
+    ;
+}
+class A2 extends core::Object {
+  synthetic constructor •() → self::A2
+    : super core::Object::•()
+    ;
+}
+class B extends core::Object implements self::A, self::A1, self::A2 {
+  synthetic constructor •() → self::B
+    : super core::Object::•()
+    ;
+}
+class C extends core::Object implements self::B {
+  synthetic constructor •() → self::C
+    : super core::Object::•()
+    ;
+}
+class D extends core::Object implements self::C {
+  synthetic constructor •() → self::D
+    : super core::Object::•()
+    ;
+}
+static field core::bool inStrongMode = !(<core::int?>[] is{ForNonNullableByDefault} core::List<core::int>);
+static const field core::bool f_is_fType = #C1;
+static const field core::bool f_is_gType = #C2;
+static const field core::bool g_is_fType = #C1;
+static const field core::bool g_is_gType = #C1;
+static const field core::bool f_is_bigType = #C2;
+static const field core::bool f1_is_t1 = #C2;
+static const field core::bool f2_is_t1 = #C2;
+static const field core::bool f3_is_t1 = #C2;
+static const field core::bool f4_is_t1 = #C2;
+static const field core::bool f5_is_t1 = #C1;
+static method f({required core::int i = #C3}) → core::int {
+  return i.{core::num::+}(1);
+}
+static method g({core::int i = #C4}) → core::int {
+  return i.{core::num::+}(1);
+}
+static method f1(core::int i, self::B b, core::Map<core::int, core::num> m, dynamic x, {required dynamic extraParam = #C3, required core::bool obool = #C3, required dynamic ox = #C3, required self::D ob = #C3, required core::List<core::num>? ol = #C3}) → self::B
+  return new self::B::•();
+static method f2(core::int i, self::D b, core::Map<core::int, core::int> m, (core::Object) → self::B x, {required (core::Object) → self::B ox = #C3, required self::D ob = #C3, required core::List<core::int> ol = #C3, required core::bool obool = #C3}) → self::D
+  return new self::D::•();
+static method f3(core::num i, self::A b, core::Map<core::Object, core::Object> m, dynamic x, {required dynamic ox = #C3, required dynamic extraParam = #C3, required self::A2 ob = #C3, required core::List<dynamic> ol = #C3, required core::Object obool = #C3}) → self::C
+  return new self::C::•();
+static method f4(core::num i, self::A b, core::Map<core::Object, core::Object> m, dynamic x, {required dynamic ox = #C3, required self::A2 ob = #C3, required core::List<dynamic> ol = #C3, required core::bool obool = #C3, required self::A xx = #C3, required self::B yy = #C3}) → self::C
+  return new self::C::•();
+static method f5(core::int i, self::A b, core::Map<core::Object, core::Object> m, dynamic x, {required dynamic ox = #C3, required self::B ob = #C3, required core::List<dynamic> ol = #C3, required dynamic obool = #C3}) → self::C
+  return new self::C::•();
+static method main() → dynamic {
+  self::expect(true, #C1);
+  self::expect((#C5) is{ForNonNullableByDefault} ({required i: core::int}) → core::int, #C1);
+  self::expect(!self::inStrongMode, #C2);
+  self::expect((#C5) is{ForNonNullableByDefault} ({i: core::int}) → core::int, #C2);
+  self::expect(true, #C1);
+  self::expect((#C6) is{ForNonNullableByDefault} ({required i: core::int}) → core::int, #C1);
+  self::expect(true, #C1);
+  self::expect((#C6) is{ForNonNullableByDefault} ({i: core::int}) → core::int, #C1);
+  self::expect(false, #C2);
+  self::expect((#C5) is{ForNonNullableByDefault} ({required i1: core::int, required i10: core::int, required i11: core::int, required i12: core::int, required i13: core::int, required i14: core::int, required i15: core::int, required i16: core::int, required i17: core::int, required i18: core::int, required i19: core::int, required i2: core::int, required i20: core::int, required i21: core::int, required i22: core::int, required i23: core::int, required i24: core::int, required i25: core::int, required i26: core::int, required i27: core::int, required i28: core::int, required i29: core::int, required i3: core::int, required i30: core::int, required i31: core::int, required i32: core::int, required i33: core::int, required i34: core::int, required i35: core::int, required i36: core::int, required i37: core::int, required i38: core::int, required i39: core::int, required i4: core::int, required i40: core::int, required i41: core::int, required i42: core::int, required i43: core::int, required i44: core::int, required i45: core::int, required i46: core::int, required i47: core::int, required i48: core::int, required i49: core::int, required i5: core::int, required i50: core::int, required i51: core::int, required i52: core::int, required i53: core::int, required i54: core::int, required i55: core::int, required i56: core::int, required i57: core::int, required i58: core::int, required i59: core::int, required i6: core::int, required i60: core::int, required i61: core::int, required i62: core::int, required i63: core::int, required i64: core::int, required i65: core::int, required i66: core::int, required i67: core::int, required i68: core::int, required i69: core::int, required i7: core::int, required i70: core::int, required i8: core::int, required i9: core::int}) → core::int, #C2);
+  self::expect(false, #C2);
+  self::expect((#C7) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C2);
+  self::expect(false, #C2);
+  self::expect((#C8) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C2);
+  self::expect(!self::inStrongMode, #C2);
+  self::expect((#C9) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C2);
+  self::expect(!self::inStrongMode, #C2);
+  self::expect((#C10) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C2);
+  self::expect(true, #C1);
+  self::expect((#C11) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C1);
+}
+static method expect(dynamic expected, dynamic actual) → dynamic {
+  if(!expected.{core::Object::==}(actual))
+    throw "Expected ${expected}, actual ${actual}";
+}
+
+constants  {
+  #C1 = true
+  #C2 = false
+  #C3 = null
+  #C4 = 1
+  #C5 = tearoff self::f
+  #C6 = tearoff self::g
+  #C7 = tearoff self::f1
+  #C8 = tearoff self::f2
+  #C9 = tearoff self::f3
+  #C10 = tearoff self::f4
+  #C11 = tearoff self::f5
+}
+
+Extra constant evaluation status:
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:157:12 -> BoolConstant(true)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:159:12 -> BoolConstant(false)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:161:12 -> BoolConstant(true)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:163:12 -> BoolConstant(true)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:165:12 -> BoolConstant(false)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:168:13 -> BoolConstant(false)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:170:13 -> BoolConstant(false)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:172:13 -> BoolConstant(false)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:174:13 -> BoolConstant(false)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:176:13 -> BoolConstant(true)
+Extra constant evaluation: evaluated: 56, effectively constant: 10
diff --git a/pkg/front_end/testcases/nnbd/const_is.dart.textual_outline.expect b/pkg/front_end/testcases/nnbd/const_is.dart.textual_outline.expect
new file mode 100644
index 0000000..48d1d0a
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd/const_is.dart.textual_outline.expect
@@ -0,0 +1,138 @@
+bool inStrongMode = <int?>[] is! List<int>;
+int f({required int i}) {}
+int g({int i = 1}) {}
+typedef int fType({required int i});
+typedef int gType({int i});
+typedef int bigType(
+    {required int i1,
+    required int i2,
+    required int i3,
+    required int i4,
+    required int i5,
+    required int i6,
+    required int i7,
+    required int i8,
+    required int i9,
+    required int i10,
+    required int i11,
+    required int i12,
+    required int i13,
+    required int i14,
+    required int i15,
+    required int i16,
+    required int i17,
+    required int i18,
+    required int i19,
+    required int i20,
+    required int i21,
+    required int i22,
+    required int i23,
+    required int i24,
+    required int i25,
+    required int i26,
+    required int i27,
+    required int i28,
+    required int i29,
+    required int i30,
+    required int i31,
+    required int i32,
+    required int i33,
+    required int i34,
+    required int i35,
+    required int i36,
+    required int i37,
+    required int i38,
+    required int i39,
+    required int i40,
+    required int i41,
+    required int i42,
+    required int i43,
+    required int i44,
+    required int i45,
+    required int i46,
+    required int i47,
+    required int i48,
+    required int i49,
+    required int i50,
+    required int i51,
+    required int i52,
+    required int i53,
+    required int i54,
+    required int i55,
+    required int i56,
+    required int i57,
+    required int i58,
+    required int i59,
+    required int i60,
+    required int i61,
+    required int i62,
+    required int i63,
+    required int i64,
+    required int i65,
+    required int i66,
+    required int i67,
+    required int i68,
+    required int i69,
+    required int i70});
+
+class A {}
+
+class A1 {}
+
+class A2 {}
+
+class B implements A, A1, A2 {}
+
+class C implements B {}
+
+class D implements C {}
+
+typedef B func(Object o);
+typedef B t1(int i, B b, Map<int, num> m, var x,
+    {required var ox,
+    required B ob,
+    required List<num> ol,
+    required bool obool});
+B f1(int i, B b, Map<int, num> m, var x,
+        {required extraParam,
+        required bool obool,
+        required var ox,
+        required D ob,
+        required List<num>? ol}) =>
+    new B();
+D f2(int i, D b, Map<int, int> m, func x,
+        {required func ox,
+        required D ob,
+        required List<int> ol,
+        required bool obool}) =>
+    new D();
+C f3(num i, A b, Map<Object, Object> m, var x,
+        {required var ox,
+        required extraParam,
+        required A2 ob,
+        required List ol,
+        required Object obool}) =>
+    new C();
+C f4(num i, A b, Map<Object, Object> m, var x,
+        {required var ox,
+        required A2 ob,
+        required List ol,
+        required bool obool,
+        required A xx,
+        required B yy}) =>
+    new C();
+C f5(int i, A b, Map<Object, Object> m, var x,
+        {required ox, required B ob, required List ol, required obool}) =>
+    new C();
+const f_is_fType = f is fType;
+const f_is_gType = f is gType;
+const g_is_fType = g is fType;
+const g_is_gType = g is gType;
+const f_is_bigType = f is bigType;
+const f1_is_t1 = f1 is t1;
+const f2_is_t1 = f2 is t1;
+const f3_is_t1 = f3 is t1;
+const f4_is_t1 = f4 is t1;
+const f5_is_t1 = f5 is t1;
+main() {}
+expect(expected, actual) {}
diff --git a/pkg/front_end/testcases/nnbd/const_is.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/nnbd/const_is.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..5e166ea
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd/const_is.dart.textual_outline_modelled.expect
@@ -0,0 +1,138 @@
+B f1(int i, B b, Map<int, num> m, var x,
+        {required extraParam,
+        required bool obool,
+        required var ox,
+        required D ob,
+        required List<num>? ol}) =>
+    new B();
+C f3(num i, A b, Map<Object, Object> m, var x,
+        {required var ox,
+        required extraParam,
+        required A2 ob,
+        required List ol,
+        required Object obool}) =>
+    new C();
+C f4(num i, A b, Map<Object, Object> m, var x,
+        {required var ox,
+        required A2 ob,
+        required List ol,
+        required bool obool,
+        required A xx,
+        required B yy}) =>
+    new C();
+C f5(int i, A b, Map<Object, Object> m, var x,
+        {required ox, required B ob, required List ol, required obool}) =>
+    new C();
+D f2(int i, D b, Map<int, int> m, func x,
+        {required func ox,
+        required D ob,
+        required List<int> ol,
+        required bool obool}) =>
+    new D();
+bool inStrongMode = <int?>[] is! List<int>;
+
+class A {}
+
+class A1 {}
+
+class A2 {}
+
+class B implements A, A1, A2 {}
+
+class C implements B {}
+
+class D implements C {}
+
+const f1_is_t1 = f1 is t1;
+const f2_is_t1 = f2 is t1;
+const f3_is_t1 = f3 is t1;
+const f4_is_t1 = f4 is t1;
+const f5_is_t1 = f5 is t1;
+const f_is_bigType = f is bigType;
+const f_is_fType = f is fType;
+const f_is_gType = f is gType;
+const g_is_fType = g is fType;
+const g_is_gType = g is gType;
+expect(expected, actual) {}
+int f({required int i}) {}
+int g({int i = 1}) {}
+main() {}
+typedef B func(Object o);
+typedef B t1(int i, B b, Map<int, num> m, var x,
+    {required var ox,
+    required B ob,
+    required List<num> ol,
+    required bool obool});
+typedef int bigType(
+    {required int i1,
+    required int i2,
+    required int i3,
+    required int i4,
+    required int i5,
+    required int i6,
+    required int i7,
+    required int i8,
+    required int i9,
+    required int i10,
+    required int i11,
+    required int i12,
+    required int i13,
+    required int i14,
+    required int i15,
+    required int i16,
+    required int i17,
+    required int i18,
+    required int i19,
+    required int i20,
+    required int i21,
+    required int i22,
+    required int i23,
+    required int i24,
+    required int i25,
+    required int i26,
+    required int i27,
+    required int i28,
+    required int i29,
+    required int i30,
+    required int i31,
+    required int i32,
+    required int i33,
+    required int i34,
+    required int i35,
+    required int i36,
+    required int i37,
+    required int i38,
+    required int i39,
+    required int i40,
+    required int i41,
+    required int i42,
+    required int i43,
+    required int i44,
+    required int i45,
+    required int i46,
+    required int i47,
+    required int i48,
+    required int i49,
+    required int i50,
+    required int i51,
+    required int i52,
+    required int i53,
+    required int i54,
+    required int i55,
+    required int i56,
+    required int i57,
+    required int i58,
+    required int i59,
+    required int i60,
+    required int i61,
+    required int i62,
+    required int i63,
+    required int i64,
+    required int i65,
+    required int i66,
+    required int i67,
+    required int i68,
+    required int i69,
+    required int i70});
+typedef int fType({required int i});
+typedef int gType({int i});
diff --git a/pkg/front_end/testcases/nnbd/const_is.dart.weak.expect b/pkg/front_end/testcases/nnbd/const_is.dart.weak.expect
new file mode 100644
index 0000000..f6c3bba
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd/const_is.dart.weak.expect
@@ -0,0 +1,106 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef fType = ({required i: core::int}) → core::int;
+typedef gType = ({i: core::int}) → core::int;
+typedef bigType = ({required i1: core::int, required i10: core::int, required i11: core::int, required i12: core::int, required i13: core::int, required i14: core::int, required i15: core::int, required i16: core::int, required i17: core::int, required i18: core::int, required i19: core::int, required i2: core::int, required i20: core::int, required i21: core::int, required i22: core::int, required i23: core::int, required i24: core::int, required i25: core::int, required i26: core::int, required i27: core::int, required i28: core::int, required i29: core::int, required i3: core::int, required i30: core::int, required i31: core::int, required i32: core::int, required i33: core::int, required i34: core::int, required i35: core::int, required i36: core::int, required i37: core::int, required i38: core::int, required i39: core::int, required i4: core::int, required i40: core::int, required i41: core::int, required i42: core::int, required i43: core::int, required i44: core::int, required i45: core::int, required i46: core::int, required i47: core::int, required i48: core::int, required i49: core::int, required i5: core::int, required i50: core::int, required i51: core::int, required i52: core::int, required i53: core::int, required i54: core::int, required i55: core::int, required i56: core::int, required i57: core::int, required i58: core::int, required i59: core::int, required i6: core::int, required i60: core::int, required i61: core::int, required i62: core::int, required i63: core::int, required i64: core::int, required i65: core::int, required i66: core::int, required i67: core::int, required i68: core::int, required i69: core::int, required i7: core::int, required i70: core::int, required i8: core::int, required i9: core::int}) → core::int;
+typedef func = (core::Object) → self::B;
+typedef t1 = (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B;
+class A extends core::Object {
+  synthetic constructor •() → self::A
+    : super core::Object::•()
+    ;
+}
+class A1 extends core::Object {
+  synthetic constructor •() → self::A1
+    : super core::Object::•()
+    ;
+}
+class A2 extends core::Object {
+  synthetic constructor •() → self::A2
+    : super core::Object::•()
+    ;
+}
+class B extends core::Object implements self::A, self::A1, self::A2 {
+  synthetic constructor •() → self::B
+    : super core::Object::•()
+    ;
+}
+class C extends core::Object implements self::B {
+  synthetic constructor •() → self::C
+    : super core::Object::•()
+    ;
+}
+class D extends core::Object implements self::C {
+  synthetic constructor •() → self::D
+    : super core::Object::•()
+    ;
+}
+static field core::bool inStrongMode = !(<core::int?>[] is{ForNonNullableByDefault} core::List<core::int>);
+static const field core::bool f_is_fType = #C1;
+static const field core::bool f_is_gType = #C1;
+static const field core::bool g_is_fType = #C1;
+static const field core::bool g_is_gType = #C1;
+static const field core::bool f_is_bigType = #C2;
+static const field core::bool f1_is_t1 = #C2;
+static const field core::bool f2_is_t1 = #C2;
+static const field core::bool f3_is_t1 = #C1;
+static const field core::bool f4_is_t1 = #C1;
+static const field core::bool f5_is_t1 = #C1;
+static method f({required core::int i = #C3}) → core::int {
+  return i.{core::num::+}(1);
+}
+static method g({core::int i = #C4}) → core::int {
+  return i.{core::num::+}(1);
+}
+static method f1(core::int i, self::B b, core::Map<core::int, core::num> m, dynamic x, {required dynamic extraParam = #C3, required core::bool obool = #C3, required dynamic ox = #C3, required self::D ob = #C3, required core::List<core::num>? ol = #C3}) → self::B
+  return new self::B::•();
+static method f2(core::int i, self::D b, core::Map<core::int, core::int> m, (core::Object) → self::B x, {required (core::Object) → self::B ox = #C3, required self::D ob = #C3, required core::List<core::int> ol = #C3, required core::bool obool = #C3}) → self::D
+  return new self::D::•();
+static method f3(core::num i, self::A b, core::Map<core::Object, core::Object> m, dynamic x, {required dynamic ox = #C3, required dynamic extraParam = #C3, required self::A2 ob = #C3, required core::List<dynamic> ol = #C3, required core::Object obool = #C3}) → self::C
+  return new self::C::•();
+static method f4(core::num i, self::A b, core::Map<core::Object, core::Object> m, dynamic x, {required dynamic ox = #C3, required self::A2 ob = #C3, required core::List<dynamic> ol = #C3, required core::bool obool = #C3, required self::A xx = #C3, required self::B yy = #C3}) → self::C
+  return new self::C::•();
+static method f5(core::int i, self::A b, core::Map<core::Object, core::Object> m, dynamic x, {required dynamic ox = #C3, required self::B ob = #C3, required core::List<dynamic> ol = #C3, required dynamic obool = #C3}) → self::C
+  return new self::C::•();
+static method main() → dynamic {
+  self::expect(true, #C1);
+  self::expect((#C5) is{ForNonNullableByDefault} ({required i: core::int}) → core::int, #C1);
+  self::expect(!self::inStrongMode, #C1);
+  self::expect((#C5) is{ForNonNullableByDefault} ({i: core::int}) → core::int, #C1);
+  self::expect(true, #C1);
+  self::expect((#C6) is{ForNonNullableByDefault} ({required i: core::int}) → core::int, #C1);
+  self::expect(true, #C1);
+  self::expect((#C6) is{ForNonNullableByDefault} ({i: core::int}) → core::int, #C1);
+  self::expect(false, #C2);
+  self::expect((#C5) is{ForNonNullableByDefault} ({required i1: core::int, required i10: core::int, required i11: core::int, required i12: core::int, required i13: core::int, required i14: core::int, required i15: core::int, required i16: core::int, required i17: core::int, required i18: core::int, required i19: core::int, required i2: core::int, required i20: core::int, required i21: core::int, required i22: core::int, required i23: core::int, required i24: core::int, required i25: core::int, required i26: core::int, required i27: core::int, required i28: core::int, required i29: core::int, required i3: core::int, required i30: core::int, required i31: core::int, required i32: core::int, required i33: core::int, required i34: core::int, required i35: core::int, required i36: core::int, required i37: core::int, required i38: core::int, required i39: core::int, required i4: core::int, required i40: core::int, required i41: core::int, required i42: core::int, required i43: core::int, required i44: core::int, required i45: core::int, required i46: core::int, required i47: core::int, required i48: core::int, required i49: core::int, required i5: core::int, required i50: core::int, required i51: core::int, required i52: core::int, required i53: core::int, required i54: core::int, required i55: core::int, required i56: core::int, required i57: core::int, required i58: core::int, required i59: core::int, required i6: core::int, required i60: core::int, required i61: core::int, required i62: core::int, required i63: core::int, required i64: core::int, required i65: core::int, required i66: core::int, required i67: core::int, required i68: core::int, required i69: core::int, required i7: core::int, required i70: core::int, required i8: core::int, required i9: core::int}) → core::int, #C2);
+  self::expect(false, #C2);
+  self::expect((#C7) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C2);
+  self::expect(false, #C2);
+  self::expect((#C8) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C2);
+  self::expect(!self::inStrongMode, #C1);
+  self::expect((#C9) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C1);
+  self::expect(!self::inStrongMode, #C1);
+  self::expect((#C10) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C1);
+  self::expect(true, #C1);
+  self::expect((#C11) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C1);
+}
+static method expect(dynamic expected, dynamic actual) → dynamic {
+  if(!expected.{core::Object::==}(actual))
+    throw "Expected ${expected}, actual ${actual}";
+}
+
+constants  {
+  #C1 = true
+  #C2 = false
+  #C3 = null
+  #C4 = 1
+  #C5 = tearoff self::f
+  #C6 = tearoff self::g
+  #C7 = tearoff self::f1
+  #C8 = tearoff self::f2
+  #C9 = tearoff self::f3
+  #C10 = tearoff self::f4
+  #C11 = tearoff self::f5
+}
diff --git a/pkg/front_end/testcases/nnbd/const_is.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd/const_is.dart.weak.transformed.expect
new file mode 100644
index 0000000..5d2b393
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd/const_is.dart.weak.transformed.expect
@@ -0,0 +1,119 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+typedef fType = ({required i: core::int}) → core::int;
+typedef gType = ({i: core::int}) → core::int;
+typedef bigType = ({required i1: core::int, required i10: core::int, required i11: core::int, required i12: core::int, required i13: core::int, required i14: core::int, required i15: core::int, required i16: core::int, required i17: core::int, required i18: core::int, required i19: core::int, required i2: core::int, required i20: core::int, required i21: core::int, required i22: core::int, required i23: core::int, required i24: core::int, required i25: core::int, required i26: core::int, required i27: core::int, required i28: core::int, required i29: core::int, required i3: core::int, required i30: core::int, required i31: core::int, required i32: core::int, required i33: core::int, required i34: core::int, required i35: core::int, required i36: core::int, required i37: core::int, required i38: core::int, required i39: core::int, required i4: core::int, required i40: core::int, required i41: core::int, required i42: core::int, required i43: core::int, required i44: core::int, required i45: core::int, required i46: core::int, required i47: core::int, required i48: core::int, required i49: core::int, required i5: core::int, required i50: core::int, required i51: core::int, required i52: core::int, required i53: core::int, required i54: core::int, required i55: core::int, required i56: core::int, required i57: core::int, required i58: core::int, required i59: core::int, required i6: core::int, required i60: core::int, required i61: core::int, required i62: core::int, required i63: core::int, required i64: core::int, required i65: core::int, required i66: core::int, required i67: core::int, required i68: core::int, required i69: core::int, required i7: core::int, required i70: core::int, required i8: core::int, required i9: core::int}) → core::int;
+typedef func = (core::Object) → self::B;
+typedef t1 = (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B;
+class A extends core::Object {
+  synthetic constructor •() → self::A
+    : super core::Object::•()
+    ;
+}
+class A1 extends core::Object {
+  synthetic constructor •() → self::A1
+    : super core::Object::•()
+    ;
+}
+class A2 extends core::Object {
+  synthetic constructor •() → self::A2
+    : super core::Object::•()
+    ;
+}
+class B extends core::Object implements self::A, self::A1, self::A2 {
+  synthetic constructor •() → self::B
+    : super core::Object::•()
+    ;
+}
+class C extends core::Object implements self::B {
+  synthetic constructor •() → self::C
+    : super core::Object::•()
+    ;
+}
+class D extends core::Object implements self::C {
+  synthetic constructor •() → self::D
+    : super core::Object::•()
+    ;
+}
+static field core::bool inStrongMode = !(<core::int?>[] is{ForNonNullableByDefault} core::List<core::int>);
+static const field core::bool f_is_fType = #C1;
+static const field core::bool f_is_gType = #C1;
+static const field core::bool g_is_fType = #C1;
+static const field core::bool g_is_gType = #C1;
+static const field core::bool f_is_bigType = #C2;
+static const field core::bool f1_is_t1 = #C2;
+static const field core::bool f2_is_t1 = #C2;
+static const field core::bool f3_is_t1 = #C1;
+static const field core::bool f4_is_t1 = #C1;
+static const field core::bool f5_is_t1 = #C1;
+static method f({required core::int i = #C3}) → core::int {
+  return i.{core::num::+}(1);
+}
+static method g({core::int i = #C4}) → core::int {
+  return i.{core::num::+}(1);
+}
+static method f1(core::int i, self::B b, core::Map<core::int, core::num> m, dynamic x, {required dynamic extraParam = #C3, required core::bool obool = #C3, required dynamic ox = #C3, required self::D ob = #C3, required core::List<core::num>? ol = #C3}) → self::B
+  return new self::B::•();
+static method f2(core::int i, self::D b, core::Map<core::int, core::int> m, (core::Object) → self::B x, {required (core::Object) → self::B ox = #C3, required self::D ob = #C3, required core::List<core::int> ol = #C3, required core::bool obool = #C3}) → self::D
+  return new self::D::•();
+static method f3(core::num i, self::A b, core::Map<core::Object, core::Object> m, dynamic x, {required dynamic ox = #C3, required dynamic extraParam = #C3, required self::A2 ob = #C3, required core::List<dynamic> ol = #C3, required core::Object obool = #C3}) → self::C
+  return new self::C::•();
+static method f4(core::num i, self::A b, core::Map<core::Object, core::Object> m, dynamic x, {required dynamic ox = #C3, required self::A2 ob = #C3, required core::List<dynamic> ol = #C3, required core::bool obool = #C3, required self::A xx = #C3, required self::B yy = #C3}) → self::C
+  return new self::C::•();
+static method f5(core::int i, self::A b, core::Map<core::Object, core::Object> m, dynamic x, {required dynamic ox = #C3, required self::B ob = #C3, required core::List<dynamic> ol = #C3, required dynamic obool = #C3}) → self::C
+  return new self::C::•();
+static method main() → dynamic {
+  self::expect(true, #C1);
+  self::expect((#C5) is{ForNonNullableByDefault} ({required i: core::int}) → core::int, #C1);
+  self::expect(!self::inStrongMode, #C1);
+  self::expect((#C5) is{ForNonNullableByDefault} ({i: core::int}) → core::int, #C1);
+  self::expect(true, #C1);
+  self::expect((#C6) is{ForNonNullableByDefault} ({required i: core::int}) → core::int, #C1);
+  self::expect(true, #C1);
+  self::expect((#C6) is{ForNonNullableByDefault} ({i: core::int}) → core::int, #C1);
+  self::expect(false, #C2);
+  self::expect((#C5) is{ForNonNullableByDefault} ({required i1: core::int, required i10: core::int, required i11: core::int, required i12: core::int, required i13: core::int, required i14: core::int, required i15: core::int, required i16: core::int, required i17: core::int, required i18: core::int, required i19: core::int, required i2: core::int, required i20: core::int, required i21: core::int, required i22: core::int, required i23: core::int, required i24: core::int, required i25: core::int, required i26: core::int, required i27: core::int, required i28: core::int, required i29: core::int, required i3: core::int, required i30: core::int, required i31: core::int, required i32: core::int, required i33: core::int, required i34: core::int, required i35: core::int, required i36: core::int, required i37: core::int, required i38: core::int, required i39: core::int, required i4: core::int, required i40: core::int, required i41: core::int, required i42: core::int, required i43: core::int, required i44: core::int, required i45: core::int, required i46: core::int, required i47: core::int, required i48: core::int, required i49: core::int, required i5: core::int, required i50: core::int, required i51: core::int, required i52: core::int, required i53: core::int, required i54: core::int, required i55: core::int, required i56: core::int, required i57: core::int, required i58: core::int, required i59: core::int, required i6: core::int, required i60: core::int, required i61: core::int, required i62: core::int, required i63: core::int, required i64: core::int, required i65: core::int, required i66: core::int, required i67: core::int, required i68: core::int, required i69: core::int, required i7: core::int, required i70: core::int, required i8: core::int, required i9: core::int}) → core::int, #C2);
+  self::expect(false, #C2);
+  self::expect((#C7) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C2);
+  self::expect(false, #C2);
+  self::expect((#C8) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C2);
+  self::expect(!self::inStrongMode, #C1);
+  self::expect((#C9) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C1);
+  self::expect(!self::inStrongMode, #C1);
+  self::expect((#C10) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C1);
+  self::expect(true, #C1);
+  self::expect((#C11) is{ForNonNullableByDefault} (core::int, self::B, core::Map<core::int, core::num>, dynamic, {required ob: self::B, required obool: core::bool, required ol: core::List<core::num>, required ox: dynamic}) → self::B, #C1);
+}
+static method expect(dynamic expected, dynamic actual) → dynamic {
+  if(!expected.{core::Object::==}(actual))
+    throw "Expected ${expected}, actual ${actual}";
+}
+
+constants  {
+  #C1 = true
+  #C2 = false
+  #C3 = null
+  #C4 = 1
+  #C5 = tearoff self::f
+  #C6 = tearoff self::g
+  #C7 = tearoff self::f1
+  #C8 = tearoff self::f2
+  #C9 = tearoff self::f3
+  #C10 = tearoff self::f4
+  #C11 = tearoff self::f5
+}
+
+Extra constant evaluation status:
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:157:12 -> BoolConstant(true)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:159:12 -> BoolConstant(true)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:161:12 -> BoolConstant(true)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:163:12 -> BoolConstant(true)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:165:12 -> BoolConstant(false)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:168:13 -> BoolConstant(false)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:170:13 -> BoolConstant(false)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:172:13 -> BoolConstant(true)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:174:13 -> BoolConstant(true)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:176:13 -> BoolConstant(true)
+Extra constant evaluation: evaluated: 56, effectively constant: 10
diff --git a/pkg/front_end/testcases/nnbd_mixed/const_is.dart b/pkg/front_end/testcases/nnbd_mixed/const_is.dart
new file mode 100644
index 0000000..9649a2d
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/const_is.dart
@@ -0,0 +1,27 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// Test derived from language/nnbd/subtyping/function_type_bounds_weak_test
+
+import 'const_is_lib.dart';
+
+main() {
+  // void fn<T extends Object>() is void Function<T extends Object?>()
+  // Should pass with weak checking because when the nullability information on
+  // Object and Object? are erased the type bounds are equivalent.
+  expect(true, fnWithNonNullObjectBound is fnTypeWithNullableObjectBound);
+  const test1 = fnWithNonNullObjectBound is fnTypeWithNullableObjectBound;
+  expect(true, test1);
+
+  // void fn<T extends Null>() is void Function<T extends Never>()
+  // Should pass with weak checking because because Null becomes equivalent to
+  // the bottom type.
+  expect(true, fnWithNullBound is fnTypeWithNeverBound);
+  const test2 = fnWithNullBound is fnTypeWithNeverBound;
+  expect(true, test2);
+}
+
+expect(expected, actual) {
+  if (expected != actual) throw "Expected $expected, actual $actual";
+}
diff --git a/pkg/front_end/testcases/nnbd_mixed/const_is.dart.textual_outline.expect b/pkg/front_end/testcases/nnbd_mixed/const_is.dart.textual_outline.expect
new file mode 100644
index 0000000..2b71bf0
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/const_is.dart.textual_outline.expect
@@ -0,0 +1,4 @@
+import 'const_is_lib.dart';
+
+main() {}
+expect(expected, actual) {}
diff --git a/pkg/front_end/testcases/nnbd_mixed/const_is.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/nnbd_mixed/const_is.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..0d90c13
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/const_is.dart.textual_outline_modelled.expect
@@ -0,0 +1,4 @@
+import 'const_is_lib.dart';
+
+expect(expected, actual) {}
+main() {}
diff --git a/pkg/front_end/testcases/nnbd_mixed/const_is.dart.weak.expect b/pkg/front_end/testcases/nnbd_mixed/const_is.dart.weak.expect
new file mode 100644
index 0000000..a139d60
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/const_is.dart.weak.expect
@@ -0,0 +1,33 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///const_is_lib.dart";
+
+static method main() → dynamic {
+  self::expect(true, (#C1) is{ForNonNullableByDefault} <T extends core::Object? = core::Object?>() → void);
+  self::expect(true, #C2);
+  self::expect(true, (#C3) is{ForNonNullableByDefault} <T extends Never = dynamic>() → void);
+  self::expect(true, #C2);
+}
+static method expect(dynamic expected, dynamic actual) → dynamic {
+  if(!expected.{core::Object::==}(actual))
+    throw "Expected ${expected}, actual ${actual}";
+}
+
+library /*isNonNullableByDefault*/;
+import self as self2;
+import "dart:core" as core;
+
+typedef fnTypeWithNullableObjectBound = <T extends core::Object? = core::Object?>() → void;
+typedef fnTypeWithNeverBound = <T extends Never = dynamic>() → void;
+static method fnWithNonNullObjectBound<T extends core::Object = core::Object>() → void
+  return null;
+static method fnWithNullBound<T extends core::Null? = core::Null?>() → void
+  return null;
+
+constants  {
+  #C1 = tearoff self2::fnWithNonNullObjectBound
+  #C2 = true
+  #C3 = tearoff self2::fnWithNullBound
+}
diff --git a/pkg/front_end/testcases/nnbd_mixed/const_is.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd_mixed/const_is.dart.weak.transformed.expect
new file mode 100644
index 0000000..9c0d806
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/const_is.dart.weak.transformed.expect
@@ -0,0 +1,38 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///const_is_lib.dart";
+
+static method main() → dynamic {
+  self::expect(true, (#C1) is{ForNonNullableByDefault} <T extends core::Object? = core::Object?>() → void);
+  self::expect(true, #C2);
+  self::expect(true, (#C3) is{ForNonNullableByDefault} <T extends Never = dynamic>() → void);
+  self::expect(true, #C2);
+}
+static method expect(dynamic expected, dynamic actual) → dynamic {
+  if(!expected.{core::Object::==}(actual))
+    throw "Expected ${expected}, actual ${actual}";
+}
+
+library /*isNonNullableByDefault*/;
+import self as self2;
+import "dart:core" as core;
+
+typedef fnTypeWithNullableObjectBound = <T extends core::Object? = core::Object?>() → void;
+typedef fnTypeWithNeverBound = <T extends Never = dynamic>() → void;
+static method fnWithNonNullObjectBound<T extends core::Object = core::Object>() → void
+  return null;
+static method fnWithNullBound<T extends core::Null? = core::Null?>() → void
+  return null;
+
+constants  {
+  #C1 = tearoff self2::fnWithNonNullObjectBound
+  #C2 = true
+  #C3 = tearoff self2::fnWithNullBound
+}
+
+Extra constant evaluation status:
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:13:41 -> BoolConstant(true)
+Evaluated: IsExpression @ org-dartlang-testcase:///const_is.dart:20:32 -> BoolConstant(true)
+Extra constant evaluation: evaluated: 14, effectively constant: 2
diff --git a/pkg/front_end/testcases/nnbd_mixed/const_is_lib.dart b/pkg/front_end/testcases/nnbd_mixed/const_is_lib.dart
new file mode 100644
index 0000000..e3d0d48
--- /dev/null
+++ b/pkg/front_end/testcases/nnbd_mixed/const_is_lib.dart
@@ -0,0 +1,12 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// A null safe library of helper methods to construct types and values
+/// containing non-nullable and nullable (question ?) types.
+
+typedef fnTypeWithNullableObjectBound = void Function<T extends Object?>();
+typedef fnTypeWithNeverBound = void Function<T extends Never>();
+
+void fnWithNonNullObjectBound<T extends Object>() => null;
+void fnWithNullBound<T extends Null>() => null;
diff --git a/pkg/front_end/testcases/nnbd_mixed/issue41435.dart.weak.expect b/pkg/front_end/testcases/nnbd_mixed/issue41435.dart.weak.expect
index 4fa35c5..48c54ae 100644
--- a/pkg/front_end/testcases/nnbd_mixed/issue41435.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/issue41435.dart.weak.expect
@@ -7,10 +7,10 @@
 
 static method main() → void {
   core::Null? nil;
-  iss::x = null as{TypeError} Never;
-  iss::x = nil as{TypeError} Never;
-  iss::takesNever(null as{TypeError} Never);
-  iss::takesNever(nil as{TypeError} Never);
+  iss::x = null;
+  iss::x = nil;
+  iss::takesNever(null);
+  iss::takesNever(nil);
   iss::takesTakesNull(#C1);
   iss::f = (Never* x) → core::Null? {};
 }
diff --git a/pkg/front_end/testcases/nnbd_mixed/issue41435.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd_mixed/issue41435.dart.weak.transformed.expect
index 4fa35c5..48c54ae 100644
--- a/pkg/front_end/testcases/nnbd_mixed/issue41435.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/issue41435.dart.weak.transformed.expect
@@ -7,10 +7,10 @@
 
 static method main() → void {
   core::Null? nil;
-  iss::x = null as{TypeError} Never;
-  iss::x = nil as{TypeError} Never;
-  iss::takesNever(null as{TypeError} Never);
-  iss::takesNever(nil as{TypeError} Never);
+  iss::x = null;
+  iss::x = nil;
+  iss::takesNever(null);
+  iss::takesNever(nil);
   iss::takesTakesNull(#C1);
   iss::f = (Never* x) → core::Null? {};
 }
diff --git a/pkg/front_end/testcases/nnbd_mixed/member_inheritance_from_opt_out.dart.weak.expect b/pkg/front_end/testcases/nnbd_mixed/member_inheritance_from_opt_out.dart.weak.expect
index a1b69ec..973cfd4 100644
--- a/pkg/front_end/testcases/nnbd_mixed/member_inheritance_from_opt_out.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/member_inheritance_from_opt_out.dart.weak.expect
@@ -75,10 +75,8 @@
   abstract member-signature method method4c([core::int? a = #C1, core::int? b = #C1]) → core::int?; -> opt::LegacyClass::method4c
   abstract member-signature method method5a(core::int a, {core::int b = #C1}) → core::int; -> opt::LegacyClass::method5a
   abstract member-signature method method5b({core::int a = #C1, core::int b = #C1}) → core::int; -> opt::LegacyClass::method5b
-  abstract member-signature method method5c({core::int a = #C1, core::int b = #C1}) → core::int; -> opt::LegacyClass::method5c
   abstract member-signature method method6a(core::int? a, {core::int? b = #C1}) → core::int?; -> opt::LegacyClass::method6a
   abstract member-signature method method6b({core::int? a = #C1, core::int? b = #C1}) → core::int?; -> opt::LegacyClass::method6b
-  abstract member-signature method method6c({core::int? a = #C1, core::int? b = #C1}) → core::int?; -> opt::LegacyClass::method6c
   abstract member-signature get getter1() → core::int; -> opt::LegacyClass::getter1
   abstract member-signature get getter2() → core::int?; -> opt::LegacyClass::getter2
   abstract member-signature get _identityHashCode() → core::int; -> core::Object::_identityHashCode
diff --git a/pkg/front_end/testcases/nnbd_mixed/member_inheritance_from_opt_out.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd_mixed/member_inheritance_from_opt_out.dart.weak.transformed.expect
index a1b69ec..973cfd4 100644
--- a/pkg/front_end/testcases/nnbd_mixed/member_inheritance_from_opt_out.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/member_inheritance_from_opt_out.dart.weak.transformed.expect
@@ -75,10 +75,8 @@
   abstract member-signature method method4c([core::int? a = #C1, core::int? b = #C1]) → core::int?; -> opt::LegacyClass::method4c
   abstract member-signature method method5a(core::int a, {core::int b = #C1}) → core::int; -> opt::LegacyClass::method5a
   abstract member-signature method method5b({core::int a = #C1, core::int b = #C1}) → core::int; -> opt::LegacyClass::method5b
-  abstract member-signature method method5c({core::int a = #C1, core::int b = #C1}) → core::int; -> opt::LegacyClass::method5c
   abstract member-signature method method6a(core::int? a, {core::int? b = #C1}) → core::int?; -> opt::LegacyClass::method6a
   abstract member-signature method method6b({core::int? a = #C1, core::int? b = #C1}) → core::int?; -> opt::LegacyClass::method6b
-  abstract member-signature method method6c({core::int? a = #C1, core::int? b = #C1}) → core::int?; -> opt::LegacyClass::method6c
   abstract member-signature get getter1() → core::int; -> opt::LegacyClass::getter1
   abstract member-signature get getter2() → core::int?; -> opt::LegacyClass::getter2
   abstract member-signature get _identityHashCode() → core::int; -> core::Object::_identityHashCode
diff --git a/pkg/front_end/testcases/nnbd_mixed/never_opt_out.dart.weak.expect b/pkg/front_end/testcases/nnbd_mixed/never_opt_out.dart.weak.expect
index 3c9a505..1977f90 100644
--- a/pkg/front_end/testcases/nnbd_mixed/never_opt_out.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/never_opt_out.dart.weak.expect
@@ -73,19 +73,19 @@
   inferredLocalNever = localNever;
   localNever = self::optOutNever;
   self::optOutNever = self::optOutNever;
-  nev::optInNever = self::optOutNever as{TypeError} Never;
+  nev::optInNever = self::optOutNever;
   localNull = self::optOutNever;
   self::inferredOptOutNever = self::optOutNever;
   inferredLocalNever = self::optOutNever;
   localNever = nev::optInNever;
   self::optOutNever = nev::optInNever;
-  nev::optInNever = nev::optInNever as{TypeError} Never;
+  nev::optInNever = nev::optInNever;
   localNull = nev::optInNever;
   self::inferredOptOutNever = nev::optInNever;
   inferredLocalNever = nev::optInNever;
   localNever = localNull;
   self::optOutNever = localNull;
-  nev::optInNever = localNull as{TypeError} Never;
+  nev::optInNever = localNull;
   localNull = localNull;
   self::inferredOptOutNever = localNull;
   inferredLocalNever = localNull;
@@ -104,7 +104,7 @@
   self::throws(() → core::Null? => self::optOutNever = nev::throwing());
   self::throws(() → core::Null? => localNever = nev::throwing());
   self::throws(() → core::Null? => self::optOutNever = nev::throwing());
-  self::throws(() → core::Null? => nev::optInNever = nev::throwing() as{TypeError} Never);
+  self::throws(() → core::Null? => nev::optInNever = nev::throwing());
   self::throws(() → core::Null? => self::inferredOptOutNever = nev::throwing());
   self::throws(() → core::Null? => inferredLocalNever = nev::throwing());
 }
@@ -119,14 +119,6 @@
 }
 
 library /*isNonNullableByDefault*/;
-//
-// Problems in library:
-//
-// pkg/front_end/testcases/nnbd_mixed/never_opt_out_lib.dart:19:28: Error: A value of type 'Type' can't be returned from a function with return type 'Null'.
-//  - 'Type' is from 'dart:core'.
-//   Null get nullProperty => Null;
-//                            ^
-//
 import self as nev;
 import "dart:core" as core;
 import "dart:_internal" as _in;
@@ -148,10 +140,7 @@
   method nullMethod(core::Null? value) → core::Null?
     return value;
   get nullProperty() → core::Null?
-    return let final<BottomType> #t2 = invalid-expression "pkg/front_end/testcases/nnbd_mixed/never_opt_out_lib.dart:19:28: Error: A value of type 'Type' can't be returned from a function with return type 'Null'.
- - 'Type' is from 'dart:core'.
-  Null get nullProperty => Null;
-                           ^" in core::Null? as{TypeError,ForNonNullableByDefault} core::Null?;
+    return null;
   set nullProperty(core::Null? value) → void {}
 }
 static field Never optInNever = self::optOutNever;
diff --git a/pkg/front_end/testcases/nnbd_mixed/never_opt_out.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd_mixed/never_opt_out.dart.weak.transformed.expect
index bf726fb..1977f90 100644
--- a/pkg/front_end/testcases/nnbd_mixed/never_opt_out.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/never_opt_out.dart.weak.transformed.expect
@@ -1,16 +1,70 @@
 library;
 import self as self;
-import "dart:core" as core;
 import "never_opt_out_lib.dart" as nev;
+import "dart:core" as core;
 
 import "org-dartlang-testcase:///never_opt_out_lib.dart";
 
+class B extends nev::A {
+  field core::Null? neverField = null;
+  field core::Null? nullField = null;
+  synthetic constructor •() → self::B*
+    : super nev::A::•()
+    ;
+  method neverMethod(core::Null? value) → core::Null?
+    return value;
+  get neverProperty() → core::Null?
+    return null;
+  set neverProperty(core::Null? value) → void {}
+  method nullMethod(core::Null? value) → core::Null?
+    return value;
+  get nullProperty() → core::Null?
+    return null;
+  set nullProperty(core::Null? value) → void {}
+  abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
+  abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
+  abstract member-signature method _simpleInstanceOf(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOf
+  abstract member-signature method _simpleInstanceOfTrue(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOfTrue
+  abstract member-signature method _simpleInstanceOfFalse(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOfFalse
+  abstract member-signature operator ==(dynamic other) → core::bool*; -> core::Object::==
+  abstract member-signature get hashCode() → core::int*; -> core::Object::hashCode
+  abstract member-signature method toString() → core::String*; -> core::Object::toString
+  abstract member-signature method noSuchMethod(core::Invocation* invocation) → dynamic; -> core::Object::noSuchMethod
+  abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
+}
+class C extends nev::A {
+  field Never* neverField = null;
+  field Never* nullField = null;
+  synthetic constructor •() → self::C*
+    : super nev::A::•()
+    ;
+  method neverMethod(Never* value) → Never*
+    return value;
+  get neverProperty() → Never*
+    return null;
+  set neverProperty(Never* value) → void {}
+  method nullMethod(Never* value) → Never*
+    return value;
+  get nullProperty() → Never*
+    return null;
+  set nullProperty(Never* value) → void {}
+  abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
+  abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
+  abstract member-signature method _simpleInstanceOf(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOf
+  abstract member-signature method _simpleInstanceOfTrue(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOfTrue
+  abstract member-signature method _simpleInstanceOfFalse(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOfFalse
+  abstract member-signature operator ==(dynamic other) → core::bool*; -> core::Object::==
+  abstract member-signature get hashCode() → core::int*; -> core::Object::hashCode
+  abstract member-signature method toString() → core::String*; -> core::Object::toString
+  abstract member-signature method noSuchMethod(core::Invocation* invocation) → dynamic; -> core::Object::noSuchMethod
+  abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
+}
 static field Never* optOutNever;
-static field core::Null? inferredOptOutNever = nev::optInNever;
+static field dynamic inferredOptOutNever = nev::optInNever;
 static method main() → dynamic {
   Never* localNever = null;
   core::Null? localNull = null;
-  Never inferredLocalNever = nev::optInNever;
+  dynamic inferredLocalNever = nev::optInNever;
   localNever = localNever;
   self::optOutNever = localNever;
   nev::optInNever = localNever;
@@ -31,28 +85,28 @@
   inferredLocalNever = nev::optInNever;
   localNever = localNull;
   self::optOutNever = localNull;
-  nev::optInNever = localNull as{TypeError} Never;
+  nev::optInNever = localNull;
   localNull = localNull;
   self::inferredOptOutNever = localNull;
-  inferredLocalNever = localNull as{TypeError} Never;
-  localNever = self::inferredOptOutNever;
-  self::optOutNever = self::inferredOptOutNever;
-  nev::optInNever = self::inferredOptOutNever as{TypeError} Never;
-  localNull = self::inferredOptOutNever;
+  inferredLocalNever = localNull;
+  localNever = self::inferredOptOutNever as{TypeError,ForDynamic} Never*;
+  self::optOutNever = self::inferredOptOutNever as{TypeError,ForDynamic} Never*;
+  nev::optInNever = self::inferredOptOutNever as{TypeError,ForDynamic} Never;
+  localNull = self::inferredOptOutNever as{TypeError,ForDynamic} core::Null?;
   self::inferredOptOutNever = self::inferredOptOutNever;
-  inferredLocalNever = self::inferredOptOutNever as{TypeError} Never;
-  localNever = inferredLocalNever;
-  self::optOutNever = inferredLocalNever;
-  nev::optInNever = inferredLocalNever;
-  localNull = inferredLocalNever;
+  inferredLocalNever = self::inferredOptOutNever;
+  localNever = inferredLocalNever as{TypeError,ForDynamic} Never*;
+  self::optOutNever = inferredLocalNever as{TypeError,ForDynamic} Never*;
+  nev::optInNever = inferredLocalNever as{TypeError,ForDynamic} Never;
+  localNull = inferredLocalNever as{TypeError,ForDynamic} core::Null?;
   self::inferredOptOutNever = inferredLocalNever;
   inferredLocalNever = inferredLocalNever;
-  self::throws(() → Never => self::optOutNever = nev::throwing());
-  self::throws(() → Never => localNever = nev::throwing());
-  self::throws(() → Never => self::optOutNever = nev::throwing());
-  self::throws(() → Never => nev::optInNever = nev::throwing());
-  self::throws(() → Never => self::inferredOptOutNever = nev::throwing());
-  self::throws(() → Never => inferredLocalNever = nev::throwing());
+  self::throws(() → core::Null? => self::optOutNever = nev::throwing());
+  self::throws(() → core::Null? => localNever = nev::throwing());
+  self::throws(() → core::Null? => self::optOutNever = nev::throwing());
+  self::throws(() → core::Null? => nev::optInNever = nev::throwing());
+  self::throws(() → core::Null? => self::inferredOptOutNever = nev::throwing());
+  self::throws(() → core::Null? => inferredLocalNever = nev::throwing());
 }
 static method throws(() →* void f) → dynamic {
   try {
@@ -66,10 +120,29 @@
 
 library /*isNonNullableByDefault*/;
 import self as nev;
+import "dart:core" as core;
+import "dart:_internal" as _in;
 import "never_opt_out.dart" as self;
 
 import "org-dartlang-testcase:///never_opt_out.dart";
 
+class A extends core::Object {
+  field Never neverField = throw "Should not reach here";
+  field core::Null? nullField = null;
+  synthetic constructor •() → nev::A
+    : super core::Object::•()
+    ;
+  method neverMethod(Never value) → Never
+    return let final Never #t1 = value in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
+  get neverProperty() → Never
+    return throw "Should not reach here";
+  set neverProperty(Never value) → void {}
+  method nullMethod(core::Null? value) → core::Null?
+    return value;
+  get nullProperty() → core::Null?
+    return null;
+  set nullProperty(core::Null? value) → void {}
+}
 static field Never optInNever = self::optOutNever;
 static method throwing() → Never
   return throw "Never!";
diff --git a/pkg/front_end/testcases/nnbd_mixed/never_opt_out_lib.dart b/pkg/front_end/testcases/nnbd_mixed/never_opt_out_lib.dart
index 06c5c16..a519e50 100644
--- a/pkg/front_end/testcases/nnbd_mixed/never_opt_out_lib.dart
+++ b/pkg/front_end/testcases/nnbd_mixed/never_opt_out_lib.dart
@@ -16,6 +16,6 @@
 
   Null nullField = null;
   Null nullMethod(Null value) => value;
-  Null get nullProperty => Null;
+  Null get nullProperty => null;
   void set nullProperty(Null value) {}
 }
diff --git a/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.expect b/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.expect
index 3a8e857..919f10f 100644
--- a/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.expect
@@ -256,7 +256,7 @@
   uns::unnecessaryNullAwareAccess(() → core::Null? => null);
   self::throws(() → dynamic => uns::callReturningNever(() → <BottomType>=> throw "foo"), (core::Object* e) → core::bool* => e.{core::Object::==}("foo"));
   () →* core::Null? f = () → core::Null? => null;
-  self::throws(() → dynamic => uns::callReturningNever(f as{TypeError} () → Never));
+  self::throws(() → dynamic => uns::callReturningNever(f));
   uns::switchOnEnum(#C3);
   uns::switchOnEnum(#C6);
   self::throws(() → dynamic => uns::switchOnEnum(null));
diff --git a/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.transformed.expect
index eacb84d..908eb54 100644
--- a/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/unsound_checks.dart.weak.transformed.expect
@@ -256,7 +256,7 @@
   uns::unnecessaryNullAwareAccess(() → core::Null? => null);
   self::throws(() → dynamic => uns::callReturningNever(() → <BottomType>=> throw "foo"), (core::Object* e) → core::bool* => e.{core::Object::==}("foo"));
   () →* core::Null? f = () → core::Null? => null;
-  self::throws(() → dynamic => uns::callReturningNever(f as{TypeError} () → Never));
+  self::throws(() → dynamic => uns::callReturningNever(f));
   uns::switchOnEnum(#C3);
   uns::switchOnEnum(#C6);
   self::throws(() → dynamic => uns::switchOnEnum(null));
@@ -639,4 +639,4 @@
 Evaluated: VariableGet @ org-dartlang-testcase:///unsound_checks_lib.dart:39:56 -> IntConstant(42)
 Evaluated: VariableGet @ org-dartlang-testcase:///unsound_checks_lib.dart:134:5 -> IntConstant(0)
 Evaluated: VariableGet @ org-dartlang-testcase:///unsound_checks_lib.dart:134:5 -> IntConstant(0)
-Extra constant evaluation: evaluated: 720, effectively constant: 18
+Extra constant evaluation: evaluated: 719, effectively constant: 18
diff --git a/pkg/front_end/testcases/weak.status b/pkg/front_end/testcases/weak.status
index 689551d..e652cfc 100644
--- a/pkg/front_end/testcases/weak.status
+++ b/pkg/front_end/testcases/weak.status
@@ -73,7 +73,6 @@
 nnbd_mixed/issue41567: TypeCheckError
 nnbd_mixed/messages_with_types_opt_in: TypeCheckError
 nnbd_mixed/messages_with_types_opt_out: TypeCheckError
-nnbd_mixed/never_opt_out: TypeCheckError
 value_class/simple: RuntimeError # Expected
 value_class/value_extends_non_value: RuntimeError # Expected
 value_class/value_implements_non_value: RuntimeError # Expected
diff --git a/pkg/kernel/lib/src/types.dart b/pkg/kernel/lib/src/types.dart
index 88e6940..2ab1891 100644
--- a/pkg/kernel/lib/src/types.dart
+++ b/pkg/kernel/lib/src/types.dart
@@ -482,9 +482,9 @@
         return const IsSubtypeOf.never();
       }
     }
-    List<NamedType> sNamed = s.namedParameters;
-    List<NamedType> tNamed = t.namedParameters;
-    if (sNamed.isNotEmpty || tNamed.isNotEmpty) {
+    List<NamedType> sNamedParameters = s.namedParameters;
+    List<NamedType> tNamedParameters = t.namedParameters;
+    if (sNamedParameters.isNotEmpty || tNamedParameters.isNotEmpty) {
       // Rule 16, the number of positional parameters must be the same.
       if (sPositional.length != tPositional.length) {
         return const IsSubtypeOf.never();
@@ -497,17 +497,46 @@
       // [s]. Also, for the intersection, the type of the parameter of [t] must
       // be a subtype of the type of the parameter of [s].
       int sCount = 0;
-      for (int tCount = 0; tCount < tNamed.length; tCount++) {
-        String name = tNamed[tCount].name;
-        for (; sCount < sNamed.length; sCount++) {
-          if (sNamed[sCount].name == name) break;
+      for (int tCount = 0; tCount < tNamedParameters.length; tCount++) {
+        NamedType tNamedParameter = tNamedParameters[tCount];
+        String name = tNamedParameter.name;
+        NamedType sNamedParameter;
+        for (; sCount < sNamedParameters.length; sCount++) {
+          sNamedParameter = sNamedParameters[sCount];
+          if (sNamedParameter.name == name) {
+            break;
+          } else if (sNamedParameter.isRequired) {
+            /// From the NNBD spec: For each j such that r0j is required, then
+            /// there exists an i in n+1...q such that xj = yi, and r1i is
+            /// required
+            result =
+                result.and(const IsSubtypeOf.onlyIfIgnoringNullabilities());
+          }
         }
-        if (sCount == sNamed.length) return const IsSubtypeOf.never();
+        if (sCount == sNamedParameters.length) return const IsSubtypeOf.never();
+        // Increment [sCount] so we don't check [sNamedParameter] again in the
+        // loop above or below and assume it is an extra (unmatched) parameter.
+        sCount++;
         result = result.and(types.performNullabilityAwareSubtypeCheck(
-            tNamed[tCount].type, sNamed[sCount].type));
+            tNamedParameter.type, sNamedParameter.type));
         if (!result.isSubtypeWhenIgnoringNullabilities()) {
           return const IsSubtypeOf.never();
         }
+
+        /// From the NNBD spec: For each j such that r0j is required, then there
+        /// exists an i in n+1...q such that xj = yi, and r1i is required
+        if (sNamedParameter.isRequired && !tNamedParameter.isRequired) {
+          result = result.and(const IsSubtypeOf.onlyIfIgnoringNullabilities());
+        }
+      }
+      for (; sCount < sNamedParameters.length; sCount++) {
+        NamedType sNamedParameter = sNamedParameters[sCount];
+        if (sNamedParameter.isRequired) {
+          /// From the NNBD spec: For each j such that r0j is required, then
+          /// there exists an i in n+1...q such that xj = yi, and r1i is
+          /// required
+          result = result.and(const IsSubtypeOf.onlyIfIgnoringNullabilities());
+        }
       }
     }
     return result.and(new IsSubtypeOf.basedSolelyOnNullabilities(s, t));
@@ -899,7 +928,7 @@
         return const IsSubtypeOf.always();
       }
       if (t.nullability == Nullability.nonNullable) {
-        return const IsSubtypeOf.never();
+        return const IsSubtypeOf.onlyIfIgnoringNullabilities();
       }
       throw new StateError(
           "Unexpected nullability '$t.nullability' of type Never");
diff --git a/runtime/lib/object.cc b/runtime/lib/object.cc
index e45c42d..f015232 100644
--- a/runtime/lib/object.cc
+++ b/runtime/lib/object.cc
@@ -23,7 +23,7 @@
       Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
   const char* msg = instance.ToCString();
   OS::PrintErr("Fatal error in dart:async: %s\n", msg);
-  FATAL(msg);
+  FATAL("%s", msg);
   return Object::null();
 }
 
diff --git a/runtime/platform/assert.h b/runtime/platform/assert.h
index 6b5d634..c31c1cc 100644
--- a/runtime/platform/assert.h
+++ b/runtime/platform/assert.h
@@ -208,7 +208,15 @@
 
 }  // namespace dart
 
-#define FATAL(error) dart::Assert(__FILE__, __LINE__).Fail("%s", error)
+#if defined(_MSC_VER)
+#define FATAL(format, ...)                                                     \
+  dart::Assert(__FILE__, __LINE__).Fail(format, __VA_ARGS__);
+#else
+#define FATAL(format, ...)                                                     \
+  dart::Assert(__FILE__, __LINE__).Fail(format, ##__VA_ARGS__);
+#endif
+
+// Leaving old non-varargs versions to avoid having to rewrite all uses.
 
 #define FATAL1(format, p1) dart::Assert(__FILE__, __LINE__).Fail(format, (p1))
 
diff --git a/runtime/vm/compiler/offsets_extractor.cc b/runtime/vm/compiler/offsets_extractor.cc
index a75c847..c89ff54 100644
--- a/runtime/vm/compiler/offsets_extractor.cc
+++ b/runtime/vm/compiler/offsets_extractor.cc
@@ -38,6 +38,16 @@
 class OffsetsExtractor : public AllStatic {
  public:
   static void DumpOffsets() {
+// Currently we have two different axes for offset generation:
+//
+//  * Target architecture
+//  * DART_PRECOMPILED_RUNTIME (i.e, AOT vs. JIT)
+//
+// TODO(dartbug.com/43646): Add DART_PRECOMPILER as another axis.
+
+// This doesn't use any special constants, just method calls, so no output.
+#define PRINT_PAYLOAD_SIZEOF(Class, Name, HeaderSize)
+
 #if defined(DART_PRECOMPILED_RUNTIME)
 
 #define PRINT_FIELD_OFFSET(Class, Name)                                        \
@@ -119,18 +129,19 @@
             << Class::Name << ";\n";
 
     JIT_OFFSETS_LIST(PRINT_FIELD_OFFSET, PRINT_ARRAY_LAYOUT, PRINT_SIZEOF,
-                     PRINT_RANGE, PRINT_CONSTANT)
+                     PRINT_PAYLOAD_SIZEOF, PRINT_RANGE, PRINT_CONSTANT)
 
 #endif  // defined(DART_PRECOMPILED_RUNTIME)
 
     COMMON_OFFSETS_LIST(PRINT_FIELD_OFFSET, PRINT_ARRAY_LAYOUT, PRINT_SIZEOF,
-                        PRINT_RANGE, PRINT_CONSTANT)
+                        PRINT_PAYLOAD_SIZEOF, PRINT_RANGE, PRINT_CONSTANT)
 
 #undef PRINT_FIELD_OFFSET
 #undef PRINT_ARRAY_LAYOUT
 #undef PRINT_SIZEOF
 #undef PRINT_RANGE
 #undef PRINT_CONSTANT
+#undef PRINT_PAYLOAD_SIZEOF
   }
 };
 
diff --git a/runtime/vm/compiler/relocation.cc b/runtime/vm/compiler/relocation.cc
index d84a679..a14f615 100644
--- a/runtime/vm/compiler/relocation.cc
+++ b/runtime/vm/compiler/relocation.cc
@@ -22,7 +22,7 @@
 
 const intptr_t kTrampolineSize =
     Utils::RoundUp(PcRelativeTrampolineJumpPattern::kLengthInBytes,
-                   ImageWriter::kBareInstructionsAlignment);
+                   compiler::target::Instructions::kBarePayloadAlignment);
 
 CodeRelocator::CodeRelocator(Thread* thread,
                              GrowableArray<CodePtr>* code_objects,
diff --git a/runtime/vm/compiler/runtime_api.cc b/runtime/vm/compiler/runtime_api.cc
index c313f53..06bf60c 100644
--- a/runtime/vm/compiler/runtime_api.cc
+++ b/runtime/vm/compiler/runtime_api.cc
@@ -512,8 +512,21 @@
   return TranslateOffsetInWords(dart::Context::variable_offset(n));
 }
 
+// Currently we have two different axes for offset generation:
+//
+//  * Target architecture
+//  * DART_PRECOMPILED_RUNTIME (i.e, AOT vs. JIT)
+//
+// TODO(dartbug.com/43646): Add DART_PRECOMPILER as another axis.
+
 #define DEFINE_CONSTANT(Class, Name) const word Class::Name = Class##_##Name;
 
+#define DEFINE_PAYLOAD_SIZEOF(clazz, name, header)                             \
+  word clazz::name() { return 0; }                                             \
+  word clazz::name(word payload_size) {                                        \
+    return RoundedAllocationSize(clazz::header() + payload_size);              \
+  }
+
 #if defined(TARGET_ARCH_IA32)
 
 #define DEFINE_FIELD(clazz, name)                                              \
@@ -536,12 +549,14 @@
 JIT_OFFSETS_LIST(DEFINE_FIELD,
                  DEFINE_ARRAY,
                  DEFINE_SIZEOF,
+                 DEFINE_PAYLOAD_SIZEOF,
                  DEFINE_RANGE,
                  DEFINE_CONSTANT)
 
 COMMON_OFFSETS_LIST(DEFINE_FIELD,
                     DEFINE_ARRAY,
                     DEFINE_SIZEOF,
+                    DEFINE_PAYLOAD_SIZEOF,
                     DEFINE_RANGE,
                     DEFINE_CONSTANT)
 
@@ -586,6 +601,7 @@
 JIT_OFFSETS_LIST(DEFINE_JIT_FIELD,
                  DEFINE_JIT_ARRAY,
                  DEFINE_JIT_SIZEOF,
+                 DEFINE_PAYLOAD_SIZEOF,
                  DEFINE_JIT_RANGE,
                  DEFINE_CONSTANT)
 
@@ -628,6 +644,7 @@
 COMMON_OFFSETS_LIST(DEFINE_FIELD,
                     DEFINE_ARRAY,
                     DEFINE_SIZEOF,
+                    DEFINE_PAYLOAD_SIZEOF,
                     DEFINE_RANGE,
                     DEFINE_CONSTANT)
 
@@ -637,19 +654,44 @@
 #undef DEFINE_ARRAY
 #undef DEFINE_SIZEOF
 #undef DEFINE_RANGE
+#undef DEFINE_PAYLOAD_SIZEOF
 #undef DEFINE_CONSTANT
 
 const word StoreBufferBlock::kSize = dart::StoreBufferBlock::kSize;
 
 const word MarkingStackBlock::kSize = dart::MarkingStackBlock::kSize;
 
+// For InstructionsSections and Instructions, we define these by hand, because
+// they depend on flags or #defines.
+
 word InstructionsSection::HeaderSize() {
-  return Utils::RoundUp(InstructionsSection::UnalignedHeaderSize(),
-                        target::kWordSize);
+  // We only create InstructionsSections in precompiled mode.
+  ASSERT(FLAG_precompiled_mode);
+  return Utils::RoundUp(UnalignedHeaderSize(),
+                        Instructions::kBarePayloadAlignment);
+}
+
+// Used for Instructions methods, since we don't serialize Instructions objects
+// in bare instructions mode, just payloads.
+DART_FORCE_INLINE static bool BareInstructionsPayloads() {
+  return FLAG_precompiled_mode && FLAG_use_bare_instructions;
 }
 
 word Instructions::HeaderSize() {
-  return Utils::RoundUp(Instructions::UnalignedHeaderSize(), target::kWordSize);
+  return BareInstructionsPayloads()
+             ? 0
+             : Utils::RoundUp(UnalignedHeaderSize(), kNonBarePayloadAlignment);
+}
+
+word Instructions::InstanceSize() {
+  return 0;
+}
+
+word Instructions::InstanceSize(word payload_size) {
+  const intptr_t alignment = BareInstructionsPayloads()
+                                 ? kBarePayloadAlignment
+                                 : ObjectAlignment::kObjectAlignment;
+  return Utils::RoundUp(Instructions::HeaderSize() + payload_size, alignment);
 }
 
 word Thread::stack_overflow_shared_stub_entry_point_offset(bool fpu_regs) {
diff --git a/runtime/vm/compiler/runtime_api.h b/runtime/vm/compiler/runtime_api.h
index da31762..e4468ab 100644
--- a/runtime/vm/compiler/runtime_api.h
+++ b/runtime/vm/compiler/runtime_api.h
@@ -805,13 +805,17 @@
 
 class PcDescriptors : public AllStatic {
  public:
+  static word HeaderSize();
   static word InstanceSize();
+  static word InstanceSize(word payload_size);
   static word NextFieldOffset();
 };
 
 class CodeSourceMap : public AllStatic {
  public:
+  static word HeaderSize();
   static word InstanceSize();
+  static word InstanceSize(word payload_size);
   static word NextFieldOffset();
 };
 
@@ -819,6 +823,7 @@
  public:
   static word HeaderSize();
   static word InstanceSize();
+  static word InstanceSize(word payload_size);
   static word NextFieldOffset();
 };
 
@@ -1150,9 +1155,10 @@
 
 class InstructionsSection : public AllStatic {
  public:
-  static word HeaderSize();
   static word UnalignedHeaderSize();
+  static word HeaderSize();
   static word InstanceSize();
+  static word InstanceSize(word payload_size);
   static word NextFieldOffset();
 };
 
@@ -1162,9 +1168,12 @@
   static const word kPolymorphicEntryOffsetJIT;
   static const word kMonomorphicEntryOffsetAOT;
   static const word kPolymorphicEntryOffsetAOT;
-  static word HeaderSize();
+  static const word kBarePayloadAlignment;
+  static const word kNonBarePayloadAlignment;
   static word UnalignedHeaderSize();
+  static word HeaderSize();
   static word InstanceSize();
+  static word InstanceSize(word payload_size);
   static word NextFieldOffset();
 };
 
diff --git a/runtime/vm/compiler/runtime_offsets_extracted.h b/runtime/vm/compiler/runtime_offsets_extracted.h
index 6ad8752..349f146 100644
--- a/runtime/vm/compiler/runtime_offsets_extracted.h
+++ b/runtime/vm/compiler/runtime_offsets_extracted.h
@@ -36,6 +36,10 @@
     Instructions_kMonomorphicEntryOffsetAOT = 0;
 static constexpr dart::compiler::target::word
     Instructions_kPolymorphicEntryOffsetAOT = 12;
+static constexpr dart::compiler::target::word
+    Instructions_kBarePayloadAlignment = 4;
+static constexpr dart::compiler::target::word
+    Instructions_kNonBarePayloadAlignment = 4;
 static constexpr dart::compiler::target::word OldPage_kBytesPerCardLog2 = 9;
 static constexpr dart::compiler::target::word
     NativeEntry_kNumCallWrapperArguments = 2;
@@ -426,9 +430,7 @@
 static constexpr dart::compiler::target::word Closure_InstanceSize = 28;
 static constexpr dart::compiler::target::word ClosureData_InstanceSize = 20;
 static constexpr dart::compiler::target::word Code_InstanceSize = 96;
-static constexpr dart::compiler::target::word CodeSourceMap_InstanceSize = 8;
-static constexpr dart::compiler::target::word CompressedStackMaps_InstanceSize =
-    8;
+static constexpr dart::compiler::target::word CodeSourceMap_HeaderSize = 8;
 static constexpr dart::compiler::target::word CompressedStackMaps_HeaderSize =
     8;
 static constexpr dart::compiler::target::word Context_InstanceSize = 12;
@@ -456,11 +458,8 @@
 static constexpr dart::compiler::target::word ICData_InstanceSize = 32;
 static constexpr dart::compiler::target::word ImageHeader_UnroundedSize = 20;
 static constexpr dart::compiler::target::word Instance_InstanceSize = 4;
-static constexpr dart::compiler::target::word Instructions_InstanceSize = 8;
 static constexpr dart::compiler::target::word Instructions_UnalignedHeaderSize =
     8;
-static constexpr dart::compiler::target::word InstructionsSection_InstanceSize =
-    8;
 static constexpr dart::compiler::target::word
     InstructionsSection_UnalignedHeaderSize = 8;
 static constexpr dart::compiler::target::word Int32x4_InstanceSize = 24;
@@ -488,7 +487,7 @@
 static constexpr dart::compiler::target::word ParameterTypeCheck_InstanceSize =
     24;
 static constexpr dart::compiler::target::word PatchClass_InstanceSize = 24;
-static constexpr dart::compiler::target::word PcDescriptors_InstanceSize = 8;
+static constexpr dart::compiler::target::word PcDescriptors_HeaderSize = 8;
 static constexpr dart::compiler::target::word Pointer_InstanceSize = 12;
 static constexpr dart::compiler::target::word ReceivePort_InstanceSize = 12;
 static constexpr dart::compiler::target::word RedirectionData_InstanceSize = 16;
@@ -543,6 +542,10 @@
     Instructions_kMonomorphicEntryOffsetAOT = 8;
 static constexpr dart::compiler::target::word
     Instructions_kPolymorphicEntryOffsetAOT = 22;
+static constexpr dart::compiler::target::word
+    Instructions_kBarePayloadAlignment = 4;
+static constexpr dart::compiler::target::word
+    Instructions_kNonBarePayloadAlignment = 8;
 static constexpr dart::compiler::target::word OldPage_kBytesPerCardLog2 = 10;
 static constexpr dart::compiler::target::word
     NativeEntry_kNumCallWrapperArguments = 2;
@@ -939,9 +942,7 @@
 static constexpr dart::compiler::target::word Closure_InstanceSize = 56;
 static constexpr dart::compiler::target::word ClosureData_InstanceSize = 40;
 static constexpr dart::compiler::target::word Code_InstanceSize = 176;
-static constexpr dart::compiler::target::word CodeSourceMap_InstanceSize = 16;
-static constexpr dart::compiler::target::word CompressedStackMaps_InstanceSize =
-    12;
+static constexpr dart::compiler::target::word CodeSourceMap_HeaderSize = 16;
 static constexpr dart::compiler::target::word CompressedStackMaps_HeaderSize =
     12;
 static constexpr dart::compiler::target::word Context_InstanceSize = 24;
@@ -969,11 +970,8 @@
 static constexpr dart::compiler::target::word ICData_InstanceSize = 56;
 static constexpr dart::compiler::target::word ImageHeader_UnroundedSize = 40;
 static constexpr dart::compiler::target::word Instance_InstanceSize = 8;
-static constexpr dart::compiler::target::word Instructions_InstanceSize = 12;
 static constexpr dart::compiler::target::word Instructions_UnalignedHeaderSize =
     12;
-static constexpr dart::compiler::target::word InstructionsSection_InstanceSize =
-    16;
 static constexpr dart::compiler::target::word
     InstructionsSection_UnalignedHeaderSize = 16;
 static constexpr dart::compiler::target::word Int32x4_InstanceSize = 24;
@@ -1001,7 +999,7 @@
 static constexpr dart::compiler::target::word ParameterTypeCheck_InstanceSize =
     48;
 static constexpr dart::compiler::target::word PatchClass_InstanceSize = 48;
-static constexpr dart::compiler::target::word PcDescriptors_InstanceSize = 16;
+static constexpr dart::compiler::target::word PcDescriptors_HeaderSize = 16;
 static constexpr dart::compiler::target::word Pointer_InstanceSize = 24;
 static constexpr dart::compiler::target::word ReceivePort_InstanceSize = 24;
 static constexpr dart::compiler::target::word RedirectionData_InstanceSize = 32;
@@ -1056,6 +1054,10 @@
     Instructions_kMonomorphicEntryOffsetAOT = 0;
 static constexpr dart::compiler::target::word
     Instructions_kPolymorphicEntryOffsetAOT = 0;
+static constexpr dart::compiler::target::word
+    Instructions_kBarePayloadAlignment = 4;
+static constexpr dart::compiler::target::word
+    Instructions_kNonBarePayloadAlignment = 4;
 static constexpr dart::compiler::target::word OldPage_kBytesPerCardLog2 = 9;
 static constexpr dart::compiler::target::word
     NativeEntry_kNumCallWrapperArguments = 2;
@@ -1443,9 +1445,7 @@
 static constexpr dart::compiler::target::word Closure_InstanceSize = 28;
 static constexpr dart::compiler::target::word ClosureData_InstanceSize = 20;
 static constexpr dart::compiler::target::word Code_InstanceSize = 96;
-static constexpr dart::compiler::target::word CodeSourceMap_InstanceSize = 8;
-static constexpr dart::compiler::target::word CompressedStackMaps_InstanceSize =
-    8;
+static constexpr dart::compiler::target::word CodeSourceMap_HeaderSize = 8;
 static constexpr dart::compiler::target::word CompressedStackMaps_HeaderSize =
     8;
 static constexpr dart::compiler::target::word Context_InstanceSize = 12;
@@ -1473,11 +1473,8 @@
 static constexpr dart::compiler::target::word ICData_InstanceSize = 32;
 static constexpr dart::compiler::target::word ImageHeader_UnroundedSize = 20;
 static constexpr dart::compiler::target::word Instance_InstanceSize = 4;
-static constexpr dart::compiler::target::word Instructions_InstanceSize = 8;
 static constexpr dart::compiler::target::word Instructions_UnalignedHeaderSize =
     8;
-static constexpr dart::compiler::target::word InstructionsSection_InstanceSize =
-    8;
 static constexpr dart::compiler::target::word
     InstructionsSection_UnalignedHeaderSize = 8;
 static constexpr dart::compiler::target::word Int32x4_InstanceSize = 24;
@@ -1505,7 +1502,7 @@
 static constexpr dart::compiler::target::word ParameterTypeCheck_InstanceSize =
     24;
 static constexpr dart::compiler::target::word PatchClass_InstanceSize = 24;
-static constexpr dart::compiler::target::word PcDescriptors_InstanceSize = 8;
+static constexpr dart::compiler::target::word PcDescriptors_HeaderSize = 8;
 static constexpr dart::compiler::target::word Pointer_InstanceSize = 12;
 static constexpr dart::compiler::target::word ReceivePort_InstanceSize = 12;
 static constexpr dart::compiler::target::word RedirectionData_InstanceSize = 16;
@@ -1560,6 +1557,10 @@
     Instructions_kMonomorphicEntryOffsetAOT = 8;
 static constexpr dart::compiler::target::word
     Instructions_kPolymorphicEntryOffsetAOT = 20;
+static constexpr dart::compiler::target::word
+    Instructions_kBarePayloadAlignment = 4;
+static constexpr dart::compiler::target::word
+    Instructions_kNonBarePayloadAlignment = 8;
 static constexpr dart::compiler::target::word OldPage_kBytesPerCardLog2 = 10;
 static constexpr dart::compiler::target::word
     NativeEntry_kNumCallWrapperArguments = 2;
@@ -1957,9 +1958,7 @@
 static constexpr dart::compiler::target::word Closure_InstanceSize = 56;
 static constexpr dart::compiler::target::word ClosureData_InstanceSize = 40;
 static constexpr dart::compiler::target::word Code_InstanceSize = 176;
-static constexpr dart::compiler::target::word CodeSourceMap_InstanceSize = 16;
-static constexpr dart::compiler::target::word CompressedStackMaps_InstanceSize =
-    12;
+static constexpr dart::compiler::target::word CodeSourceMap_HeaderSize = 16;
 static constexpr dart::compiler::target::word CompressedStackMaps_HeaderSize =
     12;
 static constexpr dart::compiler::target::word Context_InstanceSize = 24;
@@ -1987,11 +1986,8 @@
 static constexpr dart::compiler::target::word ICData_InstanceSize = 56;
 static constexpr dart::compiler::target::word ImageHeader_UnroundedSize = 40;
 static constexpr dart::compiler::target::word Instance_InstanceSize = 8;
-static constexpr dart::compiler::target::word Instructions_InstanceSize = 12;
 static constexpr dart::compiler::target::word Instructions_UnalignedHeaderSize =
     12;
-static constexpr dart::compiler::target::word InstructionsSection_InstanceSize =
-    16;
 static constexpr dart::compiler::target::word
     InstructionsSection_UnalignedHeaderSize = 16;
 static constexpr dart::compiler::target::word Int32x4_InstanceSize = 24;
@@ -2019,7 +2015,7 @@
 static constexpr dart::compiler::target::word ParameterTypeCheck_InstanceSize =
     48;
 static constexpr dart::compiler::target::word PatchClass_InstanceSize = 48;
-static constexpr dart::compiler::target::word PcDescriptors_InstanceSize = 16;
+static constexpr dart::compiler::target::word PcDescriptors_HeaderSize = 16;
 static constexpr dart::compiler::target::word Pointer_InstanceSize = 24;
 static constexpr dart::compiler::target::word ReceivePort_InstanceSize = 24;
 static constexpr dart::compiler::target::word RedirectionData_InstanceSize = 32;
@@ -2076,6 +2072,10 @@
     Instructions_kMonomorphicEntryOffsetAOT = 0;
 static constexpr dart::compiler::target::word
     Instructions_kPolymorphicEntryOffsetAOT = 12;
+static constexpr dart::compiler::target::word
+    Instructions_kBarePayloadAlignment = 4;
+static constexpr dart::compiler::target::word
+    Instructions_kNonBarePayloadAlignment = 4;
 static constexpr dart::compiler::target::word OldPage_kBytesPerCardLog2 = 9;
 static constexpr dart::compiler::target::word
     NativeEntry_kNumCallWrapperArguments = 2;
@@ -2460,9 +2460,7 @@
 static constexpr dart::compiler::target::word Closure_InstanceSize = 28;
 static constexpr dart::compiler::target::word ClosureData_InstanceSize = 20;
 static constexpr dart::compiler::target::word Code_InstanceSize = 76;
-static constexpr dart::compiler::target::word CodeSourceMap_InstanceSize = 8;
-static constexpr dart::compiler::target::word CompressedStackMaps_InstanceSize =
-    8;
+static constexpr dart::compiler::target::word CodeSourceMap_HeaderSize = 8;
 static constexpr dart::compiler::target::word CompressedStackMaps_HeaderSize =
     8;
 static constexpr dart::compiler::target::word Context_InstanceSize = 12;
@@ -2490,11 +2488,8 @@
 static constexpr dart::compiler::target::word ICData_InstanceSize = 32;
 static constexpr dart::compiler::target::word ImageHeader_UnroundedSize = 20;
 static constexpr dart::compiler::target::word Instance_InstanceSize = 4;
-static constexpr dart::compiler::target::word Instructions_InstanceSize = 8;
 static constexpr dart::compiler::target::word Instructions_UnalignedHeaderSize =
     8;
-static constexpr dart::compiler::target::word InstructionsSection_InstanceSize =
-    8;
 static constexpr dart::compiler::target::word
     InstructionsSection_UnalignedHeaderSize = 8;
 static constexpr dart::compiler::target::word Int32x4_InstanceSize = 24;
@@ -2522,7 +2517,7 @@
 static constexpr dart::compiler::target::word ParameterTypeCheck_InstanceSize =
     24;
 static constexpr dart::compiler::target::word PatchClass_InstanceSize = 24;
-static constexpr dart::compiler::target::word PcDescriptors_InstanceSize = 8;
+static constexpr dart::compiler::target::word PcDescriptors_HeaderSize = 8;
 static constexpr dart::compiler::target::word Pointer_InstanceSize = 12;
 static constexpr dart::compiler::target::word ReceivePort_InstanceSize = 12;
 static constexpr dart::compiler::target::word RedirectionData_InstanceSize = 16;
@@ -2577,6 +2572,10 @@
     Instructions_kMonomorphicEntryOffsetAOT = 8;
 static constexpr dart::compiler::target::word
     Instructions_kPolymorphicEntryOffsetAOT = 22;
+static constexpr dart::compiler::target::word
+    Instructions_kBarePayloadAlignment = 4;
+static constexpr dart::compiler::target::word
+    Instructions_kNonBarePayloadAlignment = 8;
 static constexpr dart::compiler::target::word OldPage_kBytesPerCardLog2 = 10;
 static constexpr dart::compiler::target::word
     NativeEntry_kNumCallWrapperArguments = 2;
@@ -2967,9 +2966,7 @@
 static constexpr dart::compiler::target::word Closure_InstanceSize = 56;
 static constexpr dart::compiler::target::word ClosureData_InstanceSize = 40;
 static constexpr dart::compiler::target::word Code_InstanceSize = 144;
-static constexpr dart::compiler::target::word CodeSourceMap_InstanceSize = 16;
-static constexpr dart::compiler::target::word CompressedStackMaps_InstanceSize =
-    12;
+static constexpr dart::compiler::target::word CodeSourceMap_HeaderSize = 16;
 static constexpr dart::compiler::target::word CompressedStackMaps_HeaderSize =
     12;
 static constexpr dart::compiler::target::word Context_InstanceSize = 24;
@@ -2997,11 +2994,8 @@
 static constexpr dart::compiler::target::word ICData_InstanceSize = 56;
 static constexpr dart::compiler::target::word ImageHeader_UnroundedSize = 40;
 static constexpr dart::compiler::target::word Instance_InstanceSize = 8;
-static constexpr dart::compiler::target::word Instructions_InstanceSize = 12;
 static constexpr dart::compiler::target::word Instructions_UnalignedHeaderSize =
     12;
-static constexpr dart::compiler::target::word InstructionsSection_InstanceSize =
-    16;
 static constexpr dart::compiler::target::word
     InstructionsSection_UnalignedHeaderSize = 16;
 static constexpr dart::compiler::target::word Int32x4_InstanceSize = 24;
@@ -3029,7 +3023,7 @@
 static constexpr dart::compiler::target::word ParameterTypeCheck_InstanceSize =
     48;
 static constexpr dart::compiler::target::word PatchClass_InstanceSize = 48;
-static constexpr dart::compiler::target::word PcDescriptors_InstanceSize = 16;
+static constexpr dart::compiler::target::word PcDescriptors_HeaderSize = 16;
 static constexpr dart::compiler::target::word Pointer_InstanceSize = 24;
 static constexpr dart::compiler::target::word ReceivePort_InstanceSize = 24;
 static constexpr dart::compiler::target::word RedirectionData_InstanceSize = 32;
@@ -3084,6 +3078,10 @@
     Instructions_kMonomorphicEntryOffsetAOT = 0;
 static constexpr dart::compiler::target::word
     Instructions_kPolymorphicEntryOffsetAOT = 0;
+static constexpr dart::compiler::target::word
+    Instructions_kBarePayloadAlignment = 4;
+static constexpr dart::compiler::target::word
+    Instructions_kNonBarePayloadAlignment = 4;
 static constexpr dart::compiler::target::word OldPage_kBytesPerCardLog2 = 9;
 static constexpr dart::compiler::target::word
     NativeEntry_kNumCallWrapperArguments = 2;
@@ -3465,9 +3463,7 @@
 static constexpr dart::compiler::target::word Closure_InstanceSize = 28;
 static constexpr dart::compiler::target::word ClosureData_InstanceSize = 20;
 static constexpr dart::compiler::target::word Code_InstanceSize = 76;
-static constexpr dart::compiler::target::word CodeSourceMap_InstanceSize = 8;
-static constexpr dart::compiler::target::word CompressedStackMaps_InstanceSize =
-    8;
+static constexpr dart::compiler::target::word CodeSourceMap_HeaderSize = 8;
 static constexpr dart::compiler::target::word CompressedStackMaps_HeaderSize =
     8;
 static constexpr dart::compiler::target::word Context_InstanceSize = 12;
@@ -3495,11 +3491,8 @@
 static constexpr dart::compiler::target::word ICData_InstanceSize = 32;
 static constexpr dart::compiler::target::word ImageHeader_UnroundedSize = 20;
 static constexpr dart::compiler::target::word Instance_InstanceSize = 4;
-static constexpr dart::compiler::target::word Instructions_InstanceSize = 8;
 static constexpr dart::compiler::target::word Instructions_UnalignedHeaderSize =
     8;
-static constexpr dart::compiler::target::word InstructionsSection_InstanceSize =
-    8;
 static constexpr dart::compiler::target::word
     InstructionsSection_UnalignedHeaderSize = 8;
 static constexpr dart::compiler::target::word Int32x4_InstanceSize = 24;
@@ -3527,7 +3520,7 @@
 static constexpr dart::compiler::target::word ParameterTypeCheck_InstanceSize =
     24;
 static constexpr dart::compiler::target::word PatchClass_InstanceSize = 24;
-static constexpr dart::compiler::target::word PcDescriptors_InstanceSize = 8;
+static constexpr dart::compiler::target::word PcDescriptors_HeaderSize = 8;
 static constexpr dart::compiler::target::word Pointer_InstanceSize = 12;
 static constexpr dart::compiler::target::word ReceivePort_InstanceSize = 12;
 static constexpr dart::compiler::target::word RedirectionData_InstanceSize = 16;
@@ -3582,6 +3575,10 @@
     Instructions_kMonomorphicEntryOffsetAOT = 8;
 static constexpr dart::compiler::target::word
     Instructions_kPolymorphicEntryOffsetAOT = 20;
+static constexpr dart::compiler::target::word
+    Instructions_kBarePayloadAlignment = 4;
+static constexpr dart::compiler::target::word
+    Instructions_kNonBarePayloadAlignment = 8;
 static constexpr dart::compiler::target::word OldPage_kBytesPerCardLog2 = 10;
 static constexpr dart::compiler::target::word
     NativeEntry_kNumCallWrapperArguments = 2;
@@ -3973,9 +3970,7 @@
 static constexpr dart::compiler::target::word Closure_InstanceSize = 56;
 static constexpr dart::compiler::target::word ClosureData_InstanceSize = 40;
 static constexpr dart::compiler::target::word Code_InstanceSize = 144;
-static constexpr dart::compiler::target::word CodeSourceMap_InstanceSize = 16;
-static constexpr dart::compiler::target::word CompressedStackMaps_InstanceSize =
-    12;
+static constexpr dart::compiler::target::word CodeSourceMap_HeaderSize = 16;
 static constexpr dart::compiler::target::word CompressedStackMaps_HeaderSize =
     12;
 static constexpr dart::compiler::target::word Context_InstanceSize = 24;
@@ -4003,11 +3998,8 @@
 static constexpr dart::compiler::target::word ICData_InstanceSize = 56;
 static constexpr dart::compiler::target::word ImageHeader_UnroundedSize = 40;
 static constexpr dart::compiler::target::word Instance_InstanceSize = 8;
-static constexpr dart::compiler::target::word Instructions_InstanceSize = 12;
 static constexpr dart::compiler::target::word Instructions_UnalignedHeaderSize =
     12;
-static constexpr dart::compiler::target::word InstructionsSection_InstanceSize =
-    16;
 static constexpr dart::compiler::target::word
     InstructionsSection_UnalignedHeaderSize = 16;
 static constexpr dart::compiler::target::word Int32x4_InstanceSize = 24;
@@ -4035,7 +4027,7 @@
 static constexpr dart::compiler::target::word ParameterTypeCheck_InstanceSize =
     48;
 static constexpr dart::compiler::target::word PatchClass_InstanceSize = 48;
-static constexpr dart::compiler::target::word PcDescriptors_InstanceSize = 16;
+static constexpr dart::compiler::target::word PcDescriptors_HeaderSize = 16;
 static constexpr dart::compiler::target::word Pointer_InstanceSize = 24;
 static constexpr dart::compiler::target::word ReceivePort_InstanceSize = 24;
 static constexpr dart::compiler::target::word RedirectionData_InstanceSize = 32;
@@ -4091,6 +4083,10 @@
     AOT_Instructions_kMonomorphicEntryOffsetAOT = 0;
 static constexpr dart::compiler::target::word
     AOT_Instructions_kPolymorphicEntryOffsetAOT = 12;
+static constexpr dart::compiler::target::word
+    AOT_Instructions_kBarePayloadAlignment = 4;
+static constexpr dart::compiler::target::word
+    AOT_Instructions_kNonBarePayloadAlignment = 4;
 static constexpr dart::compiler::target::word AOT_OldPage_kBytesPerCardLog2 = 9;
 static constexpr dart::compiler::target::word
     AOT_NativeEntry_kNumCallWrapperArguments = 2;
@@ -4519,10 +4515,7 @@
 static constexpr dart::compiler::target::word AOT_Closure_InstanceSize = 28;
 static constexpr dart::compiler::target::word AOT_ClosureData_InstanceSize = 20;
 static constexpr dart::compiler::target::word AOT_Code_InstanceSize = 88;
-static constexpr dart::compiler::target::word AOT_CodeSourceMap_InstanceSize =
-    8;
-static constexpr dart::compiler::target::word
-    AOT_CompressedStackMaps_InstanceSize = 8;
+static constexpr dart::compiler::target::word AOT_CodeSourceMap_HeaderSize = 8;
 static constexpr dart::compiler::target::word
     AOT_CompressedStackMaps_HeaderSize = 8;
 static constexpr dart::compiler::target::word AOT_Context_InstanceSize = 12;
@@ -4553,12 +4546,9 @@
 static constexpr dart::compiler::target::word AOT_ImageHeader_UnroundedSize =
     20;
 static constexpr dart::compiler::target::word AOT_Instance_InstanceSize = 4;
-static constexpr dart::compiler::target::word AOT_Instructions_InstanceSize = 8;
 static constexpr dart::compiler::target::word
     AOT_Instructions_UnalignedHeaderSize = 8;
 static constexpr dart::compiler::target::word
-    AOT_InstructionsSection_InstanceSize = 8;
-static constexpr dart::compiler::target::word
     AOT_InstructionsSection_UnalignedHeaderSize = 8;
 static constexpr dart::compiler::target::word AOT_Int32x4_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_Integer_InstanceSize = 4;
@@ -4591,8 +4581,7 @@
 static constexpr dart::compiler::target::word
     AOT_ParameterTypeCheck_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_PatchClass_InstanceSize = 20;
-static constexpr dart::compiler::target::word AOT_PcDescriptors_InstanceSize =
-    8;
+static constexpr dart::compiler::target::word AOT_PcDescriptors_HeaderSize = 8;
 static constexpr dart::compiler::target::word AOT_Pointer_InstanceSize = 12;
 static constexpr dart::compiler::target::word AOT_ReceivePort_InstanceSize = 12;
 static constexpr dart::compiler::target::word AOT_RedirectionData_InstanceSize =
@@ -4653,6 +4642,10 @@
     AOT_Instructions_kMonomorphicEntryOffsetAOT = 8;
 static constexpr dart::compiler::target::word
     AOT_Instructions_kPolymorphicEntryOffsetAOT = 22;
+static constexpr dart::compiler::target::word
+    AOT_Instructions_kBarePayloadAlignment = 4;
+static constexpr dart::compiler::target::word
+    AOT_Instructions_kNonBarePayloadAlignment = 8;
 static constexpr dart::compiler::target::word AOT_OldPage_kBytesPerCardLog2 =
     10;
 static constexpr dart::compiler::target::word
@@ -5084,10 +5077,7 @@
 static constexpr dart::compiler::target::word AOT_Closure_InstanceSize = 56;
 static constexpr dart::compiler::target::word AOT_ClosureData_InstanceSize = 40;
 static constexpr dart::compiler::target::word AOT_Code_InstanceSize = 152;
-static constexpr dart::compiler::target::word AOT_CodeSourceMap_InstanceSize =
-    16;
-static constexpr dart::compiler::target::word
-    AOT_CompressedStackMaps_InstanceSize = 12;
+static constexpr dart::compiler::target::word AOT_CodeSourceMap_HeaderSize = 16;
 static constexpr dart::compiler::target::word
     AOT_CompressedStackMaps_HeaderSize = 12;
 static constexpr dart::compiler::target::word AOT_Context_InstanceSize = 24;
@@ -5118,13 +5108,9 @@
 static constexpr dart::compiler::target::word AOT_ImageHeader_UnroundedSize =
     40;
 static constexpr dart::compiler::target::word AOT_Instance_InstanceSize = 8;
-static constexpr dart::compiler::target::word AOT_Instructions_InstanceSize =
-    12;
 static constexpr dart::compiler::target::word
     AOT_Instructions_UnalignedHeaderSize = 12;
 static constexpr dart::compiler::target::word
-    AOT_InstructionsSection_InstanceSize = 16;
-static constexpr dart::compiler::target::word
     AOT_InstructionsSection_UnalignedHeaderSize = 16;
 static constexpr dart::compiler::target::word AOT_Int32x4_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_Integer_InstanceSize = 8;
@@ -5157,8 +5143,7 @@
 static constexpr dart::compiler::target::word
     AOT_ParameterTypeCheck_InstanceSize = 48;
 static constexpr dart::compiler::target::word AOT_PatchClass_InstanceSize = 40;
-static constexpr dart::compiler::target::word AOT_PcDescriptors_InstanceSize =
-    16;
+static constexpr dart::compiler::target::word AOT_PcDescriptors_HeaderSize = 16;
 static constexpr dart::compiler::target::word AOT_Pointer_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_ReceivePort_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_RedirectionData_InstanceSize =
@@ -5222,6 +5207,10 @@
     AOT_Instructions_kMonomorphicEntryOffsetAOT = 8;
 static constexpr dart::compiler::target::word
     AOT_Instructions_kPolymorphicEntryOffsetAOT = 20;
+static constexpr dart::compiler::target::word
+    AOT_Instructions_kBarePayloadAlignment = 4;
+static constexpr dart::compiler::target::word
+    AOT_Instructions_kNonBarePayloadAlignment = 8;
 static constexpr dart::compiler::target::word AOT_OldPage_kBytesPerCardLog2 =
     10;
 static constexpr dart::compiler::target::word
@@ -5654,10 +5643,7 @@
 static constexpr dart::compiler::target::word AOT_Closure_InstanceSize = 56;
 static constexpr dart::compiler::target::word AOT_ClosureData_InstanceSize = 40;
 static constexpr dart::compiler::target::word AOT_Code_InstanceSize = 152;
-static constexpr dart::compiler::target::word AOT_CodeSourceMap_InstanceSize =
-    16;
-static constexpr dart::compiler::target::word
-    AOT_CompressedStackMaps_InstanceSize = 12;
+static constexpr dart::compiler::target::word AOT_CodeSourceMap_HeaderSize = 16;
 static constexpr dart::compiler::target::word
     AOT_CompressedStackMaps_HeaderSize = 12;
 static constexpr dart::compiler::target::word AOT_Context_InstanceSize = 24;
@@ -5688,13 +5674,9 @@
 static constexpr dart::compiler::target::word AOT_ImageHeader_UnroundedSize =
     40;
 static constexpr dart::compiler::target::word AOT_Instance_InstanceSize = 8;
-static constexpr dart::compiler::target::word AOT_Instructions_InstanceSize =
-    12;
 static constexpr dart::compiler::target::word
     AOT_Instructions_UnalignedHeaderSize = 12;
 static constexpr dart::compiler::target::word
-    AOT_InstructionsSection_InstanceSize = 16;
-static constexpr dart::compiler::target::word
     AOT_InstructionsSection_UnalignedHeaderSize = 16;
 static constexpr dart::compiler::target::word AOT_Int32x4_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_Integer_InstanceSize = 8;
@@ -5727,8 +5709,7 @@
 static constexpr dart::compiler::target::word
     AOT_ParameterTypeCheck_InstanceSize = 48;
 static constexpr dart::compiler::target::word AOT_PatchClass_InstanceSize = 40;
-static constexpr dart::compiler::target::word AOT_PcDescriptors_InstanceSize =
-    16;
+static constexpr dart::compiler::target::word AOT_PcDescriptors_HeaderSize = 16;
 static constexpr dart::compiler::target::word AOT_Pointer_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_ReceivePort_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_RedirectionData_InstanceSize =
@@ -5791,6 +5772,10 @@
     AOT_Instructions_kMonomorphicEntryOffsetAOT = 0;
 static constexpr dart::compiler::target::word
     AOT_Instructions_kPolymorphicEntryOffsetAOT = 12;
+static constexpr dart::compiler::target::word
+    AOT_Instructions_kBarePayloadAlignment = 4;
+static constexpr dart::compiler::target::word
+    AOT_Instructions_kNonBarePayloadAlignment = 4;
 static constexpr dart::compiler::target::word AOT_OldPage_kBytesPerCardLog2 = 9;
 static constexpr dart::compiler::target::word
     AOT_NativeEntry_kNumCallWrapperArguments = 2;
@@ -6212,10 +6197,7 @@
 static constexpr dart::compiler::target::word AOT_Closure_InstanceSize = 28;
 static constexpr dart::compiler::target::word AOT_ClosureData_InstanceSize = 20;
 static constexpr dart::compiler::target::word AOT_Code_InstanceSize = 64;
-static constexpr dart::compiler::target::word AOT_CodeSourceMap_InstanceSize =
-    8;
-static constexpr dart::compiler::target::word
-    AOT_CompressedStackMaps_InstanceSize = 8;
+static constexpr dart::compiler::target::word AOT_CodeSourceMap_HeaderSize = 8;
 static constexpr dart::compiler::target::word
     AOT_CompressedStackMaps_HeaderSize = 8;
 static constexpr dart::compiler::target::word AOT_Context_InstanceSize = 12;
@@ -6246,12 +6228,9 @@
 static constexpr dart::compiler::target::word AOT_ImageHeader_UnroundedSize =
     20;
 static constexpr dart::compiler::target::word AOT_Instance_InstanceSize = 4;
-static constexpr dart::compiler::target::word AOT_Instructions_InstanceSize = 8;
 static constexpr dart::compiler::target::word
     AOT_Instructions_UnalignedHeaderSize = 8;
 static constexpr dart::compiler::target::word
-    AOT_InstructionsSection_InstanceSize = 8;
-static constexpr dart::compiler::target::word
     AOT_InstructionsSection_UnalignedHeaderSize = 8;
 static constexpr dart::compiler::target::word AOT_Int32x4_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_Integer_InstanceSize = 4;
@@ -6284,8 +6263,7 @@
 static constexpr dart::compiler::target::word
     AOT_ParameterTypeCheck_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_PatchClass_InstanceSize = 20;
-static constexpr dart::compiler::target::word AOT_PcDescriptors_InstanceSize =
-    8;
+static constexpr dart::compiler::target::word AOT_PcDescriptors_HeaderSize = 8;
 static constexpr dart::compiler::target::word AOT_Pointer_InstanceSize = 12;
 static constexpr dart::compiler::target::word AOT_ReceivePort_InstanceSize = 12;
 static constexpr dart::compiler::target::word AOT_RedirectionData_InstanceSize =
@@ -6346,6 +6324,10 @@
     AOT_Instructions_kMonomorphicEntryOffsetAOT = 8;
 static constexpr dart::compiler::target::word
     AOT_Instructions_kPolymorphicEntryOffsetAOT = 22;
+static constexpr dart::compiler::target::word
+    AOT_Instructions_kBarePayloadAlignment = 4;
+static constexpr dart::compiler::target::word
+    AOT_Instructions_kNonBarePayloadAlignment = 8;
 static constexpr dart::compiler::target::word AOT_OldPage_kBytesPerCardLog2 =
     10;
 static constexpr dart::compiler::target::word
@@ -6770,10 +6752,7 @@
 static constexpr dart::compiler::target::word AOT_Closure_InstanceSize = 56;
 static constexpr dart::compiler::target::word AOT_ClosureData_InstanceSize = 40;
 static constexpr dart::compiler::target::word AOT_Code_InstanceSize = 120;
-static constexpr dart::compiler::target::word AOT_CodeSourceMap_InstanceSize =
-    16;
-static constexpr dart::compiler::target::word
-    AOT_CompressedStackMaps_InstanceSize = 12;
+static constexpr dart::compiler::target::word AOT_CodeSourceMap_HeaderSize = 16;
 static constexpr dart::compiler::target::word
     AOT_CompressedStackMaps_HeaderSize = 12;
 static constexpr dart::compiler::target::word AOT_Context_InstanceSize = 24;
@@ -6804,13 +6783,9 @@
 static constexpr dart::compiler::target::word AOT_ImageHeader_UnroundedSize =
     40;
 static constexpr dart::compiler::target::word AOT_Instance_InstanceSize = 8;
-static constexpr dart::compiler::target::word AOT_Instructions_InstanceSize =
-    12;
 static constexpr dart::compiler::target::word
     AOT_Instructions_UnalignedHeaderSize = 12;
 static constexpr dart::compiler::target::word
-    AOT_InstructionsSection_InstanceSize = 16;
-static constexpr dart::compiler::target::word
     AOT_InstructionsSection_UnalignedHeaderSize = 16;
 static constexpr dart::compiler::target::word AOT_Int32x4_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_Integer_InstanceSize = 8;
@@ -6843,8 +6818,7 @@
 static constexpr dart::compiler::target::word
     AOT_ParameterTypeCheck_InstanceSize = 48;
 static constexpr dart::compiler::target::word AOT_PatchClass_InstanceSize = 40;
-static constexpr dart::compiler::target::word AOT_PcDescriptors_InstanceSize =
-    16;
+static constexpr dart::compiler::target::word AOT_PcDescriptors_HeaderSize = 16;
 static constexpr dart::compiler::target::word AOT_Pointer_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_ReceivePort_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_RedirectionData_InstanceSize =
@@ -6908,6 +6882,10 @@
     AOT_Instructions_kMonomorphicEntryOffsetAOT = 8;
 static constexpr dart::compiler::target::word
     AOT_Instructions_kPolymorphicEntryOffsetAOT = 20;
+static constexpr dart::compiler::target::word
+    AOT_Instructions_kBarePayloadAlignment = 4;
+static constexpr dart::compiler::target::word
+    AOT_Instructions_kNonBarePayloadAlignment = 8;
 static constexpr dart::compiler::target::word AOT_OldPage_kBytesPerCardLog2 =
     10;
 static constexpr dart::compiler::target::word
@@ -7333,10 +7311,7 @@
 static constexpr dart::compiler::target::word AOT_Closure_InstanceSize = 56;
 static constexpr dart::compiler::target::word AOT_ClosureData_InstanceSize = 40;
 static constexpr dart::compiler::target::word AOT_Code_InstanceSize = 120;
-static constexpr dart::compiler::target::word AOT_CodeSourceMap_InstanceSize =
-    16;
-static constexpr dart::compiler::target::word
-    AOT_CompressedStackMaps_InstanceSize = 12;
+static constexpr dart::compiler::target::word AOT_CodeSourceMap_HeaderSize = 16;
 static constexpr dart::compiler::target::word
     AOT_CompressedStackMaps_HeaderSize = 12;
 static constexpr dart::compiler::target::word AOT_Context_InstanceSize = 24;
@@ -7367,13 +7342,9 @@
 static constexpr dart::compiler::target::word AOT_ImageHeader_UnroundedSize =
     40;
 static constexpr dart::compiler::target::word AOT_Instance_InstanceSize = 8;
-static constexpr dart::compiler::target::word AOT_Instructions_InstanceSize =
-    12;
 static constexpr dart::compiler::target::word
     AOT_Instructions_UnalignedHeaderSize = 12;
 static constexpr dart::compiler::target::word
-    AOT_InstructionsSection_InstanceSize = 16;
-static constexpr dart::compiler::target::word
     AOT_InstructionsSection_UnalignedHeaderSize = 16;
 static constexpr dart::compiler::target::word AOT_Int32x4_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_Integer_InstanceSize = 8;
@@ -7406,8 +7377,7 @@
 static constexpr dart::compiler::target::word
     AOT_ParameterTypeCheck_InstanceSize = 48;
 static constexpr dart::compiler::target::word AOT_PatchClass_InstanceSize = 40;
-static constexpr dart::compiler::target::word AOT_PcDescriptors_InstanceSize =
-    16;
+static constexpr dart::compiler::target::word AOT_PcDescriptors_HeaderSize = 16;
 static constexpr dart::compiler::target::word AOT_Pointer_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_ReceivePort_InstanceSize = 24;
 static constexpr dart::compiler::target::word AOT_RedirectionData_InstanceSize =
diff --git a/runtime/vm/compiler/runtime_offsets_list.h b/runtime/vm/compiler/runtime_offsets_list.h
index 01874c4..fca139c 100644
--- a/runtime/vm/compiler/runtime_offsets_list.h
+++ b/runtime/vm/compiler/runtime_offsets_list.h
@@ -21,7 +21,11 @@
 // FIELD(Class, Name) Offset of a field within a class.
 // ARRAY(Class, Name) Offset of the first element and the size of the elements
 //     in an array of this class.
-// SIZEOF(Class, Name, What) Size of an object.
+// SIZEOF(Class, Name, What) Class::Name() is defined as sizeof(What).
+// PAYLOAD_SIZEOF(Class, Name, HeaderSize) Instance size for a payload object.
+//     Defines Class::Name(word payload_size) and uses Class::HeaderSize(),
+//     which should give the size of the header before the payload. Also
+//     defines Class::Name() (with no payload size argument) to be 0.
 // RANGE(Class, Name, Type, First, Last, Filter) An array of offsets generated
 //     by passing a value of the given Type in the range from First to Last to
 //     Class::Name() if Filter returns true for that value.
@@ -31,7 +35,11 @@
 // JIT_OFFSETS_LIST is for declarations that are only valid in JIT mode.
 // A declaration that is not valid in product mode can be wrapped with
 // NOT_IN_PRODUCT().
-#define COMMON_OFFSETS_LIST(FIELD, ARRAY, SIZEOF, RANGE, CONSTANT)             \
+//
+// TODO(dartbug.com/43646): Add DART_PRECOMPILER as another axis.
+
+#define COMMON_OFFSETS_LIST(FIELD, ARRAY, SIZEOF, PAYLOAD_SIZEOF, RANGE,       \
+                            CONSTANT)                                          \
   ARRAY(ObjectPool, element_offset)                                            \
   CONSTANT(Array, kMaxElements)                                                \
   CONSTANT(Array, kMaxNewSpaceElements)                                        \
@@ -39,6 +47,8 @@
   CONSTANT(Instructions, kPolymorphicEntryOffsetJIT)                           \
   CONSTANT(Instructions, kMonomorphicEntryOffsetAOT)                           \
   CONSTANT(Instructions, kPolymorphicEntryOffsetAOT)                           \
+  CONSTANT(Instructions, kBarePayloadAlignment)                                \
+  CONSTANT(Instructions, kNonBarePayloadAlignment)                             \
   CONSTANT(OldPage, kBytesPerCardLog2)                                         \
   CONSTANT(NativeEntry, kNumCallWrapperArguments)                              \
   CONSTANT(String, kMaxElements)                                               \
@@ -286,8 +296,7 @@
   SIZEOF(Closure, InstanceSize, ClosureLayout)                                 \
   SIZEOF(ClosureData, InstanceSize, ClosureDataLayout)                         \
   SIZEOF(Code, InstanceSize, CodeLayout)                                       \
-  SIZEOF(CodeSourceMap, InstanceSize, CodeSourceMapLayout)                     \
-  SIZEOF(CompressedStackMaps, InstanceSize, CompressedStackMapsLayout)         \
+  SIZEOF(CodeSourceMap, HeaderSize, CodeSourceMapLayout)                       \
   SIZEOF(CompressedStackMaps, HeaderSize, CompressedStackMapsLayout)           \
   SIZEOF(Context, InstanceSize, ContextLayout)                                 \
   SIZEOF(Context, header_size, ContextLayout)                                  \
@@ -308,9 +317,7 @@
   SIZEOF(ICData, InstanceSize, ICDataLayout)                                   \
   SIZEOF(ImageHeader, UnroundedSize, ImageHeaderLayout)                        \
   SIZEOF(Instance, InstanceSize, InstanceLayout)                               \
-  SIZEOF(Instructions, InstanceSize, InstructionsLayout)                       \
   SIZEOF(Instructions, UnalignedHeaderSize, InstructionsLayout)                \
-  SIZEOF(InstructionsSection, InstanceSize, InstructionsSectionLayout)         \
   SIZEOF(InstructionsSection, UnalignedHeaderSize, InstructionsSectionLayout)  \
   SIZEOF(Int32x4, InstanceSize, Int32x4Layout)                                 \
   SIZEOF(Integer, InstanceSize, IntegerLayout)                                 \
@@ -332,7 +339,7 @@
   SIZEOF(OneByteString, InstanceSize, OneByteStringLayout)                     \
   SIZEOF(ParameterTypeCheck, InstanceSize, ParameterTypeCheckLayout)           \
   SIZEOF(PatchClass, InstanceSize, PatchClassLayout)                           \
-  SIZEOF(PcDescriptors, InstanceSize, PcDescriptorsLayout)                     \
+  SIZEOF(PcDescriptors, HeaderSize, PcDescriptorsLayout)                       \
   SIZEOF(Pointer, InstanceSize, PointerLayout)                                 \
   SIZEOF(ReceivePort, InstanceSize, ReceivePortLayout)                         \
   SIZEOF(RedirectionData, InstanceSize, RedirectionDataLayout)                 \
@@ -361,9 +368,14 @@
   SIZEOF(UserTag, InstanceSize, UserTagLayout)                                 \
   SIZEOF(WeakProperty, InstanceSize, WeakPropertyLayout)                       \
   SIZEOF(WeakSerializationReference, InstanceSize,                             \
-         WeakSerializationReferenceLayout)
+         WeakSerializationReferenceLayout)                                     \
+  PAYLOAD_SIZEOF(CodeSourceMap, InstanceSize, HeaderSize)                      \
+  PAYLOAD_SIZEOF(CompressedStackMaps, InstanceSize, HeaderSize)                \
+  PAYLOAD_SIZEOF(InstructionsSection, InstanceSize, HeaderSize)                \
+  PAYLOAD_SIZEOF(PcDescriptors, InstanceSize, HeaderSize)
 
-#define JIT_OFFSETS_LIST(FIELD, ARRAY, SIZEOF, RANGE, CONSTANT)                \
+#define JIT_OFFSETS_LIST(FIELD, ARRAY, SIZEOF, PAYLOAD_SIZEOF, RANGE,          \
+                         CONSTANT)                                             \
   FIELD(Function, usage_counter_offset)                                        \
   FIELD(ICData, receivers_static_type_offset)
 
diff --git a/runtime/vm/dart.cc b/runtime/vm/dart.cc
index 8805154..f271e57 100644
--- a/runtime/vm/dart.cc
+++ b/runtime/vm/dart.cc
@@ -107,6 +107,9 @@
     ok = false;                                                                \
   }
 
+// No consistency checks needed for this construct.
+#define CHECK_PAYLOAD_SIZEOF(Class, Name, HeaderSize)
+
 #if defined(DART_PRECOMPILED_RUNTIME)
 #define CHECK_FIELD(Class, Name)                                               \
   CHECK_OFFSET(Class::Name(), AOT_##Class##_##Name);
@@ -144,11 +147,12 @@
 #define CHECK_CONSTANT(Class, Name) CHECK_OFFSET(Class::Name, Class##_##Name);
 #endif  // defined(DART_PRECOMPILED_RUNTIME)
 
-  COMMON_OFFSETS_LIST(CHECK_FIELD, CHECK_ARRAY, CHECK_SIZEOF, CHECK_RANGE,
-                      CHECK_CONSTANT)
+  COMMON_OFFSETS_LIST(CHECK_FIELD, CHECK_ARRAY, CHECK_SIZEOF,
+                      CHECK_PAYLOAD_SIZEOF, CHECK_RANGE, CHECK_CONSTANT)
 
-  NOT_IN_PRECOMPILED_RUNTIME(JIT_OFFSETS_LIST(
-      CHECK_FIELD, CHECK_ARRAY, CHECK_SIZEOF, CHECK_RANGE, CHECK_CONSTANT))
+  NOT_IN_PRECOMPILED_RUNTIME(
+      JIT_OFFSETS_LIST(CHECK_FIELD, CHECK_ARRAY, CHECK_SIZEOF,
+                       CHECK_PAYLOAD_SIZEOF, CHECK_RANGE, CHECK_CONSTANT))
 
   if (!ok) {
     FATAL(
@@ -162,6 +166,7 @@
 #undef CHECK_RANGE
 #undef CHECK_CONSTANT
 #undef CHECK_OFFSET
+#undef CHECK_PAYLOAD_SIZEOF
 #endif  // !defined(IS_SIMARM_X64)
 }
 
diff --git a/runtime/vm/datastream.cc b/runtime/vm/datastream.cc
index a87cf46..6d398fe 100644
--- a/runtime/vm/datastream.cc
+++ b/runtime/vm/datastream.cc
@@ -3,10 +3,18 @@
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/datastream.h"
+
+#include "vm/compiler/runtime_api.h"
 #include "vm/zone.h"
 
 namespace dart {
 
+void BaseWriteStream::WriteTargetWord(word value) {
+  ASSERT(compiler::target::kBitsPerWord == kBitsPerWord ||
+         Utils::IsAbsoluteUint(compiler::target::kBitsPerWord, value));
+  WriteFixed(static_cast<compiler::target::word>(value));
+}
+
 MallocWriteStream::~MallocWriteStream() {
   free(buffer_);
 }
diff --git a/runtime/vm/datastream.h b/runtime/vm/datastream.h
index 03fac70..c6b3e04 100644
--- a/runtime/vm/datastream.h
+++ b/runtime/vm/datastream.h
@@ -392,14 +392,7 @@
 
   void WriteWord(uword value) { WriteFixed(value); }
 
-  void WriteTargetWord(uword value) {
-#if defined(IS_SIMARM_X64)
-    RELEASE_ASSERT(Utils::IsInt(32, static_cast<word>(value)));
-    WriteFixed(static_cast<uint32_t>(value));
-#else
-    WriteFixed(value);
-#endif
-  }
+  void WriteTargetWord(word value);
 
   void Printf(const char* format, ...) PRINTF_ATTRIBUTE(2, 3) {
     va_list args;
diff --git a/runtime/vm/image_snapshot.cc b/runtime/vm/image_snapshot.cc
index ae8efbe..ba82175 100644
--- a/runtime/vm/image_snapshot.cc
+++ b/runtime/vm/image_snapshot.cc
@@ -221,104 +221,37 @@
   return offset;
 }
 
-static intptr_t InstructionsSizeInSnapshot(InstructionsPtr raw) {
-  if (FLAG_precompiled_mode && FLAG_use_bare_instructions) {
-    // Currently, we align bare instruction payloads on 4 byte boundaries.
-    //
-    // If we later decide to align on larger boundaries to put entries at the
-    // start of cache lines, make sure to account for entry points that are
-    // _not_ at the start of the payload.
-    return Utils::RoundUp(Instructions::Size(raw),
-                          ImageWriter::kBareInstructionsAlignment);
-  }
-#if defined(IS_SIMARM_X64)
-  return Utils::RoundUp(
-      compiler::target::Instructions::HeaderSize() + Instructions::Size(raw),
-      compiler::target::ObjectAlignment::kObjectAlignment);
-#else
-  return raw->ptr()->HeapSize();
-#endif
-}
-
-#if defined(IS_SIMARM_X64)
-static intptr_t CompressedStackMapsSizeInSnapshot(intptr_t payload_size) {
-  const intptr_t unrounded_size_in_bytes =
-      compiler::target::CompressedStackMaps::HeaderSize() + payload_size;
-  return Utils::RoundUp(unrounded_size_in_bytes,
-                        compiler::target::ObjectAlignment::kObjectAlignment);
-}
-
-static intptr_t StringPayloadSize(intptr_t len, bool isOneByteString) {
-  return len * (isOneByteString ? OneByteString::kBytesPerElement
-                                : TwoByteString::kBytesPerElement);
-}
-
-static intptr_t StringSizeInSnapshot(intptr_t len, bool isOneByteString) {
-  const intptr_t unrounded_size_in_bytes =
-      (String::kSizeofRawString / 2) + StringPayloadSize(len, isOneByteString);
-  return Utils::RoundUp(unrounded_size_in_bytes,
-                        compiler::target::ObjectAlignment::kObjectAlignment);
-}
-
-static intptr_t CodeSourceMapSizeInSnapshot(intptr_t len) {
-  const intptr_t unrounded_size_in_bytes =
-      2 * compiler::target::kWordSize + len;
-  return Utils::RoundUp(unrounded_size_in_bytes,
-                        compiler::target::ObjectAlignment::kObjectAlignment);
-}
-
-static intptr_t PcDescriptorsSizeInSnapshot(intptr_t len) {
-  const intptr_t unrounded_size_in_bytes =
-      2 * compiler::target::kWordSize + len;
-  return Utils::RoundUp(unrounded_size_in_bytes,
-                        compiler::target::ObjectAlignment::kObjectAlignment);
-}
-
 intptr_t ImageWriter::SizeInSnapshot(ObjectPtr raw_object) {
   const classid_t cid = raw_object->GetClassId();
 
   switch (cid) {
     case kCompressedStackMapsCid: {
-      CompressedStackMapsPtr raw_maps =
-          static_cast<CompressedStackMapsPtr>(raw_object);
-      auto const payload_size = CompressedStackMaps::PayloadSizeOf(raw_maps);
-      return CompressedStackMapsSizeInSnapshot(payload_size);
-    }
-    case kOneByteStringCid:
-    case kTwoByteStringCid: {
-      StringPtr raw_str = static_cast<StringPtr>(raw_object);
-      return StringSizeInSnapshot(Smi::Value(raw_str->ptr()->length_),
-                                  cid == kOneByteStringCid);
+      auto raw_maps = CompressedStackMaps::RawCast(raw_object);
+      return compiler::target::CompressedStackMaps::InstanceSize(
+          CompressedStackMaps::PayloadSizeOf(raw_maps));
     }
     case kCodeSourceMapCid: {
-      CodeSourceMapPtr raw_map = static_cast<CodeSourceMapPtr>(raw_object);
-      return CodeSourceMapSizeInSnapshot(raw_map->ptr()->length_);
+      auto raw_map = CodeSourceMap::RawCast(raw_object);
+      return compiler::target::CodeSourceMap::InstanceSize(
+          raw_map->ptr()->length_);
     }
     case kPcDescriptorsCid: {
-      PcDescriptorsPtr raw_desc = static_cast<PcDescriptorsPtr>(raw_object);
-      return PcDescriptorsSizeInSnapshot(raw_desc->ptr()->length_);
+      auto raw_desc = PcDescriptors::RawCast(raw_object);
+      return compiler::target::PcDescriptors::InstanceSize(
+          raw_desc->ptr()->length_);
     }
     case kInstructionsCid: {
-      InstructionsPtr raw_insns = static_cast<InstructionsPtr>(raw_object);
-      return InstructionsSizeInSnapshot(raw_insns);
+      auto raw_insns = Instructions::RawCast(raw_object);
+      return compiler::target::Instructions::InstanceSize(
+          Instructions::Size(raw_insns));
     }
     default: {
       const Class& clazz = Class::Handle(Object::Handle(raw_object).clazz());
-      FATAL1("Unsupported class %s in rodata section.\n", clazz.ToCString());
+      FATAL("Unsupported class %s in rodata section.\n", clazz.ToCString());
       return 0;
     }
   }
 }
-#else   // defined(IS_SIMARM_X64)
-intptr_t ImageWriter::SizeInSnapshot(ObjectPtr raw) {
-  switch (raw->GetClassId()) {
-    case kInstructionsCid:
-      return InstructionsSizeInSnapshot(static_cast<InstructionsPtr>(raw));
-    default:
-      return raw->ptr()->HeapSize();
-  }
-}
-#endif  // defined(IS_SIMARM_X64)
 
 uint32_t ImageWriter::GetDataOffsetFor(ObjectPtr raw_object) {
   intptr_t snap_size = SizeInSnapshot(raw_object);
@@ -534,88 +467,76 @@
   for (intptr_t i = 0; i < objects_.length(); i++) {
     const Object& obj = *objects_[i].obj_;
     AutoTraceImage(obj, section_start, stream);
+    auto const object_start = stream->Position();
 
     NoSafepointScope no_safepoint;
-    uword start = static_cast<uword>(obj.raw()) - kHeapObjectTag;
 
     // Write object header with the mark and read-only bits set.
-    uword marked_tags = obj.raw()->ptr()->tags_;
-    marked_tags = ObjectLayout::OldBit::update(true, marked_tags);
-    marked_tags = ObjectLayout::OldAndNotMarkedBit::update(false, marked_tags);
-    marked_tags =
-        ObjectLayout::OldAndNotRememberedBit::update(true, marked_tags);
-    marked_tags = ObjectLayout::NewBit::update(false, marked_tags);
-#if defined(HASH_IN_OBJECT_HEADER)
-    marked_tags |= static_cast<uword>(obj.raw()->ptr()->hash_) << 32;
-#endif
-
-#if defined(IS_SIMARM_X64)
+    stream->WriteTargetWord(GetMarkedTags(obj));
     if (obj.IsCompressedStackMaps()) {
       const CompressedStackMaps& map = CompressedStackMaps::Cast(obj);
-      auto const object_start = stream->Position();
-
       const intptr_t payload_size = map.payload_size();
-      const intptr_t size_in_bytes =
-          CompressedStackMapsSizeInSnapshot(payload_size);
-      marked_tags = UpdateObjectSizeForTarget(size_in_bytes, marked_tags);
-
-      stream->WriteTargetWord(marked_tags);
       stream->WriteFixed<uint32_t>(map.raw()->ptr()->flags_and_size_);
       ASSERT_EQUAL(stream->Position() - object_start,
                    compiler::target::CompressedStackMaps::HeaderSize());
       stream->WriteBytes(map.raw()->ptr()->data(), payload_size);
-      stream->Align(compiler::target::ObjectAlignment::kObjectAlignment);
-    } else if (obj.IsString()) {
-      const String& str = String::Cast(obj);
-      RELEASE_ASSERT(String::GetCachedHash(str.raw()) != 0);
-      RELEASE_ASSERT(str.IsOneByteString() || str.IsTwoByteString());
-      const intptr_t size_in_bytes =
-          StringSizeInSnapshot(str.Length(), str.IsOneByteString());
-      marked_tags = UpdateObjectSizeForTarget(size_in_bytes, marked_tags);
-
-      stream->WriteTargetWord(marked_tags);
-      stream->WriteTargetWord(static_cast<uword>(str.raw()->ptr()->length_));
-      stream->WriteTargetWord(static_cast<uword>(str.raw()->ptr()->hash_));
-      stream->WriteBytes(
-          reinterpret_cast<const void*>(start + String::kSizeofRawString),
-          StringPayloadSize(str.Length(), str.IsOneByteString()));
-      stream->Align(compiler::target::ObjectAlignment::kObjectAlignment);
     } else if (obj.IsCodeSourceMap()) {
       const CodeSourceMap& map = CodeSourceMap::Cast(obj);
-      const intptr_t size_in_bytes = CodeSourceMapSizeInSnapshot(map.Length());
-      marked_tags = UpdateObjectSizeForTarget(size_in_bytes, marked_tags);
-
-      stream->WriteTargetWord(marked_tags);
       stream->WriteTargetWord(map.Length());
+      ASSERT_EQUAL(stream->Position() - object_start,
+                   compiler::target::CodeSourceMap::HeaderSize());
       stream->WriteBytes(map.Data(), map.Length());
-      stream->Align(compiler::target::ObjectAlignment::kObjectAlignment);
     } else if (obj.IsPcDescriptors()) {
       const PcDescriptors& desc = PcDescriptors::Cast(obj);
-
-      const intptr_t size_in_bytes = PcDescriptorsSizeInSnapshot(desc.Length());
-      marked_tags = UpdateObjectSizeForTarget(size_in_bytes, marked_tags);
-
-      stream->WriteTargetWord(marked_tags);
       stream->WriteTargetWord(desc.Length());
+      ASSERT_EQUAL(stream->Position() - object_start,
+                   compiler::target::PcDescriptors::HeaderSize());
       stream->WriteBytes(desc.raw()->ptr()->data(), desc.Length());
-      stream->Align(compiler::target::ObjectAlignment::kObjectAlignment);
     } else {
       const Class& clazz = Class::Handle(obj.clazz());
-      FATAL1("Unsupported class %s in rodata section.\n", clazz.ToCString());
+      FATAL("Unsupported class %s in rodata section.\n", clazz.ToCString());
     }
-#else   // defined(IS_SIMARM_X64)
-    const uword end = start + obj.raw()->ptr()->HeapSize();
-
-    stream->WriteWord(marked_tags);
-    start += sizeof(uword);
-    for (uword* cursor = reinterpret_cast<uword*>(start);
-         cursor < reinterpret_cast<uword*>(end); cursor++) {
-      stream->WriteWord(*cursor);
-    }
-#endif  // defined(IS_SIMARM_X64)
+    stream->Align(compiler::target::ObjectAlignment::kObjectAlignment);
+    ASSERT_EQUAL(stream->Position() - object_start, SizeInSnapshot(obj));
   }
 }
 
+static UNLESS_DEBUG(constexpr) const uword kReadOnlyGCBits =
+    ObjectLayout::OldBit::encode(true) |
+    ObjectLayout::OldAndNotMarkedBit::encode(false) |
+    ObjectLayout::OldAndNotRememberedBit::encode(true) |
+    ObjectLayout::NewBit::encode(false);
+
+uword ImageWriter::GetMarkedTags(classid_t cid, intptr_t size) {
+  // ObjectLayout::SizeTag expects a size divisible by kObjectAlignment and
+  // checks this in debug mode, but the size on the target machine may not be
+  // divisible by the host machine's object alignment if they differ.
+  //
+  // We define [adjusted_size] as [size] * m, where m is the host alignment
+  // divided by the target alignment. This means [adjusted_size] encodes on the
+  // host machine to the same bits that decode to [size] on the target machine.
+  // That is,
+  //    [adjusted_size] / host align ==
+  //    [size] * (host align / target align) / host align ==
+  //    [size] / target align
+  //
+  // Since alignments are always powers of 2, we use shifts and logs.
+  const intptr_t adjusted_size =
+      size << (kObjectAlignmentLog2 -
+               compiler::target::ObjectAlignment::kObjectAlignmentLog2);
+
+  return kReadOnlyGCBits | ObjectLayout::ClassIdTag::encode(cid) |
+         ObjectLayout::SizeTag::encode(adjusted_size);
+}
+
+uword ImageWriter::GetMarkedTags(const Object& obj) {
+  return
+#if defined(HASH_IN_OBJECT_HEADER)
+      static_cast<uword>(obj.raw()->ptr()->hash_) << kBitsPerInt32 |
+#endif
+      GetMarkedTags(obj.raw()->GetClassId(), SizeInSnapshot(obj));
+}
+
 #if defined(DART_PRECOMPILER)
 class DwarfAssemblyStream : public DwarfWriteStream {
  public:
@@ -964,15 +885,8 @@
           parent_id,
           {id, V8SnapshotProfileWriter::Reference::kElement, element_offset});
     }
-    const compiler::target::uword marked_tags =
-        ObjectLayout::OldBit::encode(true) |
-        ObjectLayout::OldAndNotMarkedBit::encode(false) |
-        ObjectLayout::OldAndNotRememberedBit::encode(true) |
-        ObjectLayout::NewBit::encode(false) |
-        ObjectLayout::SizeTag::encode(
-            AdjustObjectSizeForTarget(image_header_size)) |
-        ObjectLayout::ClassIdTag::encode(kImageHeaderCid);
-    text_offset += WriteWordLiteralText(marked_tags);
+    text_offset +=
+        WriteWordLiteralText(GetMarkedTags(kImageHeaderCid, image_header_size));
 
     // An ImageHeader has four fields:
     // 1) The BSS offset from this section.
@@ -1015,28 +929,26 @@
         parent_id = id;
       }
       const intptr_t section_size = image_size - text_offset;
-      // Add the RawInstructionsSection header.
-      const compiler::target::uword marked_tags =
-          ObjectLayout::OldBit::encode(true) |
-          ObjectLayout::OldAndNotMarkedBit::encode(false) |
-          ObjectLayout::OldAndNotRememberedBit::encode(true) |
-          ObjectLayout::NewBit::encode(false) |
-          ObjectLayout::SizeTag::encode(
-              AdjustObjectSizeForTarget(section_size)) |
-          ObjectLayout::ClassIdTag::encode(kInstructionsSectionCid);
-      text_offset += WriteWordLiteralText(marked_tags);
       // Calculated using next_text_offset_, which doesn't include post-payload
       // padding to object alignment.
       const intptr_t instructions_length =
-          next_text_offset_ - (text_offset + compiler::target::kWordSize);
+          next_text_offset_ - text_offset -
+          compiler::target::InstructionsSection::HeaderSize();
+      // Add the RawInstructionsSection header.
+      text_offset += WriteWordLiteralText(
+          GetMarkedTags(kInstructionsSectionCid, section_size));
       text_offset += WriteWordLiteralText(instructions_length);
+      text_offset += Align(
+          compiler::target::Instructions::kBarePayloadAlignment, text_offset);
     }
   }
 #endif
 
   FrameUnwindPrologue();
 
+#if defined(DART_PRECOMPILER)
   PcDescriptors& descriptors = PcDescriptors::Handle(zone);
+#endif
   SnapshotTextObjectNamer namer(zone);
 
   ASSERT(offset_space_ != V8SnapshotProfileWriter::kSnapshot);
@@ -1052,15 +964,14 @@
           assembly_dwarf_->AddCode(*data.code_, SegmentRelativeOffset(vm));
     }
 #endif
-
     const auto object_name = namer.SnapshotNameFor(dwarf_index, data);
 
 #if defined(DART_PRECOMPILER)
     if (profile_writer_ != nullptr) {
       const V8SnapshotProfileWriter::ObjectId id(offset_space_, text_offset);
       auto const type = is_trampoline ? trampoline_type_ : instructions_type_;
-      const intptr_t size = is_trampoline ? data.trampoline_length
-                                          : SizeInSnapshot(data.insns_->raw());
+      const intptr_t size =
+          is_trampoline ? data.trampoline_length : SizeInSnapshot(*data.insns_);
       profile_writer_->SetObjectTypeAndName(id, type, object_name);
       profile_writer_->AttributeBytesTo(id, size);
       const intptr_t element_offset = id.second - parent_id.second;
@@ -1080,12 +991,7 @@
     }
 
     const intptr_t instr_start = text_offset;
-
-    const auto& code = *data.code_;
     const auto& insns = *data.insns_;
-    descriptors = code.pc_descriptors();
-
-    const uword payload_start = insns.PayloadStart();
 
     // 1. Write from the object start to the payload start. This includes the
     // object header and the fixed fields.  Not written for AOT snapshots using
@@ -1094,39 +1000,18 @@
       NoSafepointScope no_safepoint;
 
       // Write Instructions with the mark and read-only bits set.
-      uword marked_tags = insns.raw_ptr()->tags_;
-      marked_tags = ObjectLayout::OldBit::update(true, marked_tags);
-      marked_tags =
-          ObjectLayout::OldAndNotMarkedBit::update(false, marked_tags);
-      marked_tags =
-          ObjectLayout::OldAndNotRememberedBit::update(true, marked_tags);
-      marked_tags = ObjectLayout::NewBit::update(false, marked_tags);
-#if defined(HASH_IN_OBJECT_HEADER)
-      // Can't use GetObjectTagsAndHash because the update methods discard the
-      // high bits.
-      marked_tags |= static_cast<uword>(insns.raw_ptr()->hash_) << 32;
-#endif
-
-#if defined(IS_SIMARM_X64)
-      const intptr_t size_in_bytes = InstructionsSizeInSnapshot(insns.raw());
-      marked_tags = UpdateObjectSizeForTarget(size_in_bytes, marked_tags);
-      WriteWordLiteralText(marked_tags);
-      text_offset += sizeof(compiler::target::uword);
-      WriteWordLiteralText(insns.raw_ptr()->size_and_flags_);
-      text_offset += sizeof(compiler::target::uword);
-#else  // defined(IS_SIMARM_X64)
-      uword object_start = reinterpret_cast<uword>(insns.raw_ptr());
-      WriteWordLiteralText(marked_tags);
-      object_start += sizeof(uword);
-      text_offset += sizeof(uword);
-      text_offset += WriteByteSequence(object_start, payload_start);
-#endif  // defined(IS_SIMARM_X64)
-
-      ASSERT((text_offset - instr_start) ==
-             compiler::target::Instructions::HeaderSize());
+      text_offset += WriteWordLiteralText(GetMarkedTags(insns));
+      text_offset += WriteWordLiteralText(insns.raw_ptr()->size_and_flags_);
+      text_offset +=
+          Align(compiler::target::Instructions::kNonBarePayloadAlignment,
+                text_offset);
     }
 
+    ASSERT_EQUAL(text_offset - instr_start,
+                 compiler::target::Instructions::HeaderSize());
+
 #if defined(DART_PRECOMPILER)
+    const auto& code = *data.code_;
     if (debug_elf_ != nullptr) {
       debug_elf_->dwarf()->AddCode(code, {vm, text_offset});
     }
@@ -1137,68 +1022,69 @@
 
     {
       // 3. Write from the payload start to payload end. For AOT snapshots
-      // with bare instructions, this is the only part serialized.
+      // with bare instructions, this is the only non-padding part serialized.
       NoSafepointScope no_safepoint;
-      assert(kBareInstructionsAlignment <=
-             compiler::target::ObjectAlignment::kObjectAlignment);
-      const auto payload_align = bare_instruction_payloads
-                                     ? kBareInstructionsAlignment
-                                     : sizeof(compiler::target::uword);
-      const uword payload_size = Utils::RoundUp(insns.Size(), payload_align);
+      const uword payload_start = insns.PayloadStart();
+      // Double-check the payload alignment, since we will load and write
+      // target-sized words starting from that address.
+      ASSERT(Utils::IsAligned(payload_start, compiler::target::kWordSize));
+      const uword payload_size = insns.Size();
       const uword payload_end = payload_start + payload_size;
 
-      ASSERT(Utils::IsAligned(text_offset, payload_align));
-
 #if defined(DART_PRECOMPILER)
+      descriptors = code.pc_descriptors();
       PcDescriptors::Iterator iterator(descriptors,
                                        PcDescriptorsLayout::kBSSRelocation);
-      uword next_reloc_offset = iterator.MoveNext() ? iterator.PcOffset() : -1;
 
-      // We only generate BSS relocations that are word-sized and at
-      // word-aligned offsets in the payload.
-      auto const possible_relocations_end =
-          Utils::RoundDown(payload_end, sizeof(compiler::target::uword));
-      for (uword cursor = payload_start; cursor < possible_relocations_end;
-           cursor += sizeof(compiler::target::uword)) {
-        uword data = *reinterpret_cast<compiler::target::uword*>(cursor);
-        if ((cursor - payload_start) == next_reloc_offset) {
-          assembly_stream_->Printf("%s %s - (.) + %" Pu "\n", kLiteralPrefix,
-                                   bss_symbol, /*addend=*/data);
-          text_offset += compiler::target::kWordSize;
-          next_reloc_offset = iterator.MoveNext() ? iterator.PcOffset() : -1;
-        } else {
-          text_offset += WriteWordLiteralText(data);
-        }
+      uword cursor = payload_start;
+      while (iterator.MoveNext()) {
+        const uword next_reloc_address = payload_start + iterator.PcOffset();
+        // We only generate BSS relocations that are target word-sized and at
+        // target word-aligned offsets in the payload. Double-check this.
+        ASSERT(
+            Utils::IsAligned(next_reloc_address, compiler::target::kWordSize));
+        text_offset += WriteByteSequence(cursor, next_reloc_address);
+        const word addend =
+            *reinterpret_cast<compiler::target::word*>(next_reloc_address);
+        assembly_stream_->Printf("%s %s - (.) + %" Pd "\n", kLiteralPrefix,
+                                 bss_symbol, addend);
+        text_offset += compiler::target::kWordSize;
+        cursor = next_reloc_address + compiler::target::kWordSize;
       }
-      assert(next_reloc_offset != (possible_relocations_end - payload_start));
-      text_offset += WriteByteSequence(possible_relocations_end, payload_end);
+      text_offset += WriteByteSequence(cursor, payload_end);
 #else
       text_offset += WriteByteSequence(payload_start, payload_end);
 #endif
-
-      // 4. Write from the payload end to object end. Note we can't simply copy
-      // from the object because the host object may have less alignment filler
-      // than the target object in the cross-word case. Not written for AOT
-      // snapshots using bare instructions.
-      if (!bare_instruction_payloads) {
-        uword unaligned_size =
-            compiler::target::Instructions::HeaderSize() + payload_size;
-        uword alignment_size =
-            Utils::RoundUp(
-                unaligned_size,
-                compiler::target::ObjectAlignment::kObjectAlignment) -
-            unaligned_size;
-        while (alignment_size > 0) {
-          text_offset += WriteWordLiteralText(kBreakInstructionFiller);
-          alignment_size -= sizeof(compiler::target::uword);
-        }
-
-        ASSERT(kWordSize != compiler::target::kWordSize ||
-               (text_offset - instr_start) == insns.raw()->ptr()->HeapSize());
-      }
     }
 
-    ASSERT((text_offset - instr_start) == SizeInSnapshot(insns.raw()));
+    // 4. Write from the payload end to object end. Note we can't simply copy
+    // from the object because the host object may have less alignment filler
+    // than the target object in the cross-word case.
+    uword unpadded_end = text_offset - instr_start;
+    uword padding_size = SizeInSnapshot(insns) - unpadded_end;
+    for (; padding_size >= compiler::target::kWordSize;
+         padding_size -= compiler::target::kWordSize) {
+      text_offset += WriteWordLiteralText(kBreakInstructionFiller);
+    }
+#if defined(TARGET_ARCH_ARM)
+    // ARM never needs more padding, as instructions are word sized and all
+    // alignments are multiples of the word size.
+    ASSERT_EQUAL(padding_size, 0);
+#elif defined(TARGET_ARCH_ARM64)
+    // ARM64 may need 4 bytes of padding, but the break instruction filler
+    // is two copies of the 4-byte break instruction, so this works.
+    ASSERT(padding_size == 0 || padding_size == 4);
+#elif defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_IA32)
+    // The break instruction filler is the same single byte instruction filling
+    // a uword, so no checks needed.
+#else
+#error Unexpected target architecture.
+#endif
+    text_offset += WriteByteSequence(
+        reinterpret_cast<uword>(&kBreakInstructionFiller),
+        reinterpret_cast<uword>(&kBreakInstructionFiller) + padding_size);
+
+    ASSERT_EQUAL(text_offset - instr_start, SizeInSnapshot(insns.raw()));
   }
 
   // Should be a no-op unless writing bare instruction payloads, in which case
@@ -1376,7 +1262,7 @@
 #if defined(DART_PRECOMPILER)
   // We don't actually write a BSS segment, it's created as part of the
   // Elf constructor, but make sure it has an non-zero start.
-  ASSERT(elf_->BssStart(vm) != 0);
+  ASSERT(elf_ == nullptr || elf_->BssStart(vm) != 0);
 #endif
 }
 
@@ -1475,15 +1361,8 @@
           parent_id,
           {id, V8SnapshotProfileWriter::Reference::kElement, element_offset});
     }
-    const compiler::target::uword marked_tags =
-        ObjectLayout::OldBit::encode(true) |
-        ObjectLayout::OldAndNotMarkedBit::encode(false) |
-        ObjectLayout::OldAndNotRememberedBit::encode(true) |
-        ObjectLayout::NewBit::encode(false) |
-        ObjectLayout::SizeTag::encode(
-            AdjustObjectSizeForTarget(image_header_size)) |
-        ObjectLayout::ClassIdTag::encode(kImageHeaderCid);
-    instructions_blob_stream_->WriteTargetWord(marked_tags);
+    instructions_blob_stream_->WriteTargetWord(
+        GetMarkedTags(kImageHeaderCid, image_header_size));
 
     ASSERT(elf_ != nullptr);
     // An ImageHeader has four fields:
@@ -1529,21 +1408,16 @@
         parent_id = id;
       }
       const intptr_t section_size = image_size - text_offset;
-      // Add the RawInstructionsSection header.
-      const compiler::target::uword marked_tags =
-          ObjectLayout::OldBit::encode(true) |
-          ObjectLayout::OldAndNotMarkedBit::encode(false) |
-          ObjectLayout::OldAndNotRememberedBit::encode(true) |
-          ObjectLayout::NewBit::encode(false) |
-          ObjectLayout::SizeTag::encode(
-              AdjustObjectSizeForTarget(section_size)) |
-          ObjectLayout::ClassIdTag::encode(kInstructionsSectionCid);
-      instructions_blob_stream_->WriteTargetWord(marked_tags);
       // Uses next_text_offset_ to avoid any post-payload padding.
       const intptr_t instructions_length =
           next_text_offset_ - text_offset -
           compiler::target::InstructionsSection::HeaderSize();
+      // Add the RawInstructionsSection header.
+      instructions_blob_stream_->WriteTargetWord(
+          GetMarkedTags(kInstructionsSectionCid, section_size));
       instructions_blob_stream_->WriteTargetWord(instructions_length);
+      instructions_blob_stream_->Align(
+          compiler::target::Instructions::kBarePayloadAlignment);
       ASSERT_EQUAL(instructions_blob_stream_->Position() - text_offset,
                    compiler::target::InstructionsSection::HeaderSize());
       text_offset += compiler::target::InstructionsSection::HeaderSize();
@@ -1583,130 +1457,116 @@
 #endif
 
     if (is_trampoline) {
-      const auto start = reinterpret_cast<uword>(data.trampoline_bytes);
-      const auto end = start + data.trampoline_length;
-      text_offset += WriteByteSequence(start, end);
+      instructions_blob_stream_->WriteBytes(
+          reinterpret_cast<const void*>(data.trampoline_bytes),
+          data.trampoline_length);
+      text_offset += data.trampoline_length;
       delete[] data.trampoline_bytes;
       data.trampoline_bytes = nullptr;
       continue;
     }
 
-    const intptr_t instr_start = text_offset;
-
     const auto& insns = *data.insns_;
-    const uword payload_start = insns.PayloadStart();
-
-    ASSERT(Utils::IsAligned(payload_start, sizeof(compiler::target::uword)));
-
-    // Write Instructions with the mark and read-only bits set.
-    uword marked_tags = insns.raw_ptr()->tags_;
-    marked_tags = ObjectLayout::OldBit::update(true, marked_tags);
-    marked_tags = ObjectLayout::OldAndNotMarkedBit::update(false, marked_tags);
-    marked_tags =
-        ObjectLayout::OldAndNotRememberedBit::update(true, marked_tags);
-    marked_tags = ObjectLayout::NewBit::update(false, marked_tags);
-#if defined(HASH_IN_OBJECT_HEADER)
-    // Can't use GetObjectTagsAndHash because the update methods discard the
-    // high bits.
-    marked_tags |= static_cast<uword>(insns.raw_ptr()->hash_) << 32;
-#endif
-
-#if defined(IS_SIMARM_X64)
-    const intptr_t start_offset = instructions_blob_stream_->bytes_written();
+    const intptr_t instr_start = instructions_blob_stream_->Position();
 
     if (!bare_instruction_payloads) {
-      const intptr_t size_in_bytes = InstructionsSizeInSnapshot(insns.raw());
-      marked_tags = UpdateObjectSizeForTarget(size_in_bytes, marked_tags);
-      instructions_blob_stream_->WriteTargetWord(marked_tags);
+      // Write Instructions with the mark and read-only bits set.
+      instructions_blob_stream_->WriteTargetWord(GetMarkedTags(insns));
       instructions_blob_stream_->WriteFixed<uint32_t>(
           insns.raw_ptr()->size_and_flags_);
-    } else {
-      ASSERT(Utils::IsAligned(instructions_blob_stream_->Position(),
-                              kBareInstructionsAlignment));
+      instructions_blob_stream_->Align(
+          compiler::target::Instructions::kNonBarePayloadAlignment);
     }
-    const intptr_t payload_offset = instructions_blob_stream_->Position();
-    instructions_blob_stream_->WriteBytes(
-        reinterpret_cast<const void*>(insns.PayloadStart()), insns.Size());
-    const intptr_t alignment =
-        bare_instruction_payloads
-            ? kBareInstructionsAlignment
-            : compiler::target::ObjectAlignment::kObjectAlignment;
-    instructions_blob_stream_->Align(alignment);
-    const intptr_t end_offset = instructions_blob_stream_->bytes_written();
-    text_offset += (end_offset - start_offset);
-#else  // defined(IS_SIMARM_X64)
-    // Only payload is output in AOT snapshots.
-    const uword header_size =
-        bare_instruction_payloads
-            ? 0
-            : compiler::target::Instructions::HeaderSize();
-    const uword payload_size = SizeInSnapshot(insns.raw()) - header_size;
-    const uword object_end = payload_start + payload_size;
-    if (!bare_instruction_payloads) {
-      uword object_start = reinterpret_cast<uword>(insns.raw_ptr());
-      instructions_blob_stream_->WriteWord(marked_tags);
-      text_offset += sizeof(uword);
-      object_start += sizeof(uword);
-      text_offset += WriteByteSequence(object_start, payload_start);
-    } else {
-      ASSERT(Utils::IsAligned(instructions_blob_stream_->Position(),
-                              kBareInstructionsAlignment));
-    }
-    const intptr_t payload_offset = instructions_blob_stream_->Position();
-    text_offset += WriteByteSequence(payload_start, object_end);
-#endif
+
+    ASSERT_EQUAL(instructions_blob_stream_->Position() - instr_start,
+                 compiler::target::Instructions::HeaderSize());
 
 #if defined(DART_PRECOMPILER)
     const auto& code = *data.code_;
+    auto const payload_offset = instructions_blob_stream_->Position();
     if (elf_ != nullptr && elf_->dwarf() != nullptr) {
       elf_->dwarf()->AddCode(code, {vm, payload_offset});
     }
     if (debug_elf_ != nullptr) {
       debug_elf_->dwarf()->AddCode(code, {vm, payload_offset});
     }
+#endif
 
+    auto const payload_start =
+        reinterpret_cast<const uint8_t*>(insns.PayloadStart());
+    // Double-check the payload alignment, since we will load and write
+    // target-sized words starting from that address.
+    ASSERT(Utils::IsAligned(payload_start, compiler::target::kWordSize));
+    const intptr_t payload_size = insns.Size();
     // Don't patch the relocation if we're not generating ELF. The regular blobs
     // format does not yet support these relocations. Use
     // Code::VerifyBSSRelocations to check whether the relocations are patched
     // or not after loading.
     if (elf_ != nullptr) {
-      const intptr_t current_stream_position =
-          instructions_blob_stream_->Position();
-
+#if defined(DART_PRECOMPILER)
       descriptors = code.pc_descriptors();
-
       PcDescriptors::Iterator iterator(
           descriptors, /*kind_mask=*/PcDescriptorsLayout::kBSSRelocation);
 
+      auto const payload_end = payload_start + payload_size;
       const intptr_t bss_offset = elf_->BssStart(vm) - segment_base;
+      auto cursor = payload_start;
       while (iterator.MoveNext()) {
-        const intptr_t reloc_offset = iterator.PcOffset();
+        auto const next_reloc_offset = iterator.PcOffset();
+        auto const next_reloc_address = payload_start + next_reloc_offset;
+        // We only generate BSS relocations that are target word-sized and at
+        // target word-aligned offsets in the payload. Double-check this..
+        ASSERT(
+            Utils::IsAligned(next_reloc_address, compiler::target::kWordSize));
+        instructions_blob_stream_->WriteBytes(cursor,
+                                              next_reloc_address - cursor);
 
         // The instruction stream at the relocation position holds an offset
         // into BSS corresponding to the symbol being resolved. This addend is
         // factored into the relocation.
-        const auto addend = *reinterpret_cast<compiler::target::word*>(
-            insns.PayloadStart() + reloc_offset);
+        const auto addend = *reinterpret_cast<const compiler::target::word*>(
+            next_reloc_address);
 
-        // Overwrite the relocation position in the instruction stream with the
-        // offset of the BSS segment from the relocation position plus the
-        // addend in the relocation.
-        auto const reloc_pos = payload_offset + reloc_offset;
-        instructions_blob_stream_->SetPosition(reloc_pos);
-
-        const compiler::target::word offset = bss_offset - reloc_pos + addend;
-        instructions_blob_stream_->WriteTargetWord(offset);
+        const word reloc_value =
+            bss_offset + addend - (payload_offset + next_reloc_offset);
+        instructions_blob_stream_->WriteTargetWord(reloc_value);
+        cursor = next_reloc_address + compiler::target::kWordSize;
       }
-
-      // Restore stream position after the relocation was patched.
-      instructions_blob_stream_->SetPosition(current_stream_position);
-    }
-#else
-    USE(payload_offset);
+      instructions_blob_stream_->WriteBytes(cursor, payload_end - cursor);
 #endif
+    } else {
+      instructions_blob_stream_->WriteBytes(payload_start, payload_size);
+    }
 
-    ASSERT((text_offset - instr_start) ==
-           ImageWriter::SizeInSnapshot(insns.raw()));
+    // Create padding containing break instructions. Instead of copying it out
+    // of the object, we recreate it to handle the crossword case where the
+    // amount of padding may differ.
+    uword unpadded_end = instructions_blob_stream_->Position() - instr_start;
+    uword padding_size = SizeInSnapshot(insns) - unpadded_end;
+    for (; padding_size >= compiler::target::kWordSize;
+         padding_size -= compiler::target::kWordSize) {
+      instructions_blob_stream_->WriteTargetWord(kBreakInstructionFiller);
+    }
+#if defined(TARGET_ARCH_ARM)
+    // ARM never needs more padding, as instructions are word sized and all
+    // alignments are multiples of the word size.
+    ASSERT_EQUAL(padding_size, 0);
+#elif defined(TARGET_ARCH_ARM64)
+    // ARM64 may need 4 bytes of padding, but the break instruction filler
+    // is two copies of the 4-byte break instruction, so this works.
+    ASSERT(padding_size == 0 || padding_size == 4);
+#elif defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_IA32)
+    // The break instruction filler is the same single byte instruction filling
+    // a uword, so no checks needed.
+#else
+#error Unexpected target architecture.
+#endif
+    instructions_blob_stream_->WriteBytes(
+        reinterpret_cast<const void*>(&kBreakInstructionFiller), padding_size);
+
+    const intptr_t instr_end = instructions_blob_stream_->Position();
+    ASSERT_EQUAL(instr_end - instr_start, SizeInSnapshot(insns.raw()));
+    text_offset += instr_end - instr_start;
   }
 
   // Should be a no-op unless writing bare instruction payloads, in which case
@@ -1717,7 +1577,7 @@
   text_offset = Utils::RoundUp(
       text_offset, compiler::target::ObjectAlignment::kObjectAlignment);
 
-  ASSERT_EQUAL(text_offset, instructions_blob_stream_->bytes_written());
+  ASSERT_EQUAL(text_offset, instructions_blob_stream_->Position());
   ASSERT_EQUAL(text_offset, image_size);
 
 #if defined(DART_PRECOMPILER)
@@ -1758,17 +1618,20 @@
 
 #if defined(DART_PRECOMPILED_RUNTIME)
 uword ImageReader::GetBareInstructionsAt(uint32_t offset) const {
-  ASSERT(Utils::IsAligned(offset, ImageWriter::kBareInstructionsAlignment));
+  ASSERT(FLAG_use_bare_instructions);
+  ASSERT(Utils::IsAligned(offset, Instructions::kBarePayloadAlignment));
   return reinterpret_cast<uword>(instructions_image_) + offset;
 }
 
 uword ImageReader::GetBareInstructionsEnd() const {
+  ASSERT(FLAG_use_bare_instructions);
   Image image(instructions_image_);
   return reinterpret_cast<uword>(image.object_start()) + image.object_size();
 }
 #endif
 
 InstructionsPtr ImageReader::GetInstructionsAt(uint32_t offset) const {
+  ASSERT(!FLAG_precompiled_mode || !FLAG_use_bare_instructions);
   ASSERT(Utils::IsAligned(offset, kObjectAlignment));
 
   ObjectPtr result = ObjectLayout::FromAddr(
diff --git a/runtime/vm/image_snapshot.h b/runtime/vm/image_snapshot.h
index 44673a3..0190cae 100644
--- a/runtime/vm/image_snapshot.h
+++ b/runtime/vm/image_snapshot.h
@@ -294,35 +294,8 @@
   void TraceInstructions(const Instructions& instructions);
 
   static intptr_t SizeInSnapshot(ObjectPtr object);
-  static const intptr_t kBareInstructionsAlignment = 4;
-
-  static_assert(
-      (kObjectAlignmentLog2 -
-       compiler::target::ObjectAlignment::kObjectAlignmentLog2) >= 0,
-      "Target object alignment is larger than the host object alignment");
-
-  // Converts the target object size (in bytes) to an appropriate argument for
-  // ObjectLayout::SizeTag methods on the host machine.
-  //
-  // ObjectLayout::SizeTag expects a size divisible by kObjectAlignment and
-  // checks this in debug mode, but the size on the target machine may not be
-  // divisible by the host machine's object alignment if they differ.
-  //
-  // If target_size = n, we convert it to n * m, where m is the host alignment
-  // divided by the target alignment. This means AdjustObjectSizeForTarget(n)
-  // encodes on the host machine to the same bits that decode to n on the target
-  // machine. That is:
-  //    n * (host align / target align) / host align => n / target align
-  static constexpr intptr_t AdjustObjectSizeForTarget(intptr_t target_size) {
-    return target_size
-           << (kObjectAlignmentLog2 -
-               compiler::target::ObjectAlignment::kObjectAlignmentLog2);
-  }
-
-  static UNLESS_DEBUG(constexpr) compiler::target::uword
-      UpdateObjectSizeForTarget(intptr_t size, uword marked_tags) {
-    return ObjectLayout::SizeTag::update(AdjustObjectSizeForTarget(size),
-                                         marked_tags);
+  static intptr_t SizeInSnapshot(const Object& object) {
+    return SizeInSnapshot(object.raw());
   }
 
   // Returns nullptr if there is no profile writer.
@@ -334,6 +307,9 @@
   virtual void WriteROData(NonStreamingWriteStream* clustered_stream, bool vm);
   virtual void WriteText(bool vm) = 0;
 
+  static uword GetMarkedTags(classid_t cid, intptr_t size);
+  static uword GetMarkedTags(const Object& obj);
+
   void DumpInstructionStats();
   void DumpInstructionsSizes();
 
@@ -484,16 +460,12 @@
   const char* kLiteralPrefix = ".long";
 #endif
 
-  intptr_t WriteWordLiteralText(uword value) {
-#if defined(IS_SIMARM_X64)
-    ASSERT(value <= kMaxUint32);
-#endif
+  intptr_t WriteWordLiteralText(word value) {
+    ASSERT(compiler::target::kBitsPerWord == kBitsPerWord ||
+           Utils::IsAbsoluteUint(compiler::target::kBitsPerWord, value));
     // Padding is helpful for comparing the .S with --disassemble.
-#if defined(TARGET_ARCH_IS_64_BIT)
-    assembly_stream_->Printf(".quad 0x%0.16" Px "\n", value);
-#else
-    assembly_stream_->Printf(".long 0x%0.8" Px "\n", value);
-#endif
+    assembly_stream_->Printf("%s 0x%0.*" Px "\n", kLiteralPrefix,
+                             2 * compiler::target::kWordSize, value);
     return compiler::target::kWordSize;
   }
 
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 38e8461..9577ff4 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -5510,21 +5510,50 @@
       (kMaxInt32 - (sizeof(InstructionsLayout) + sizeof(ObjectLayout) +
                     (2 * kMaxObjectAlignment)));
 
+  // Currently, we align bare instruction payloads on 4 byte boundaries.
+  //
+  // If we later decide to align on larger boundaries to put entries at the
+  // start of cache lines, make sure to account for entry points that are
+  // _not_ at the start of the payload.
+  static const intptr_t kBarePayloadAlignment = 4;
+
+  // In non-bare mode, we align the payloads on word boundaries.
+  static const intptr_t kNonBarePayloadAlignment = kWordSize;
+
+  // In the precompiled runtime when running in bare instructions mode,
+  // Instructions objects don't exist, just their bare payloads, so we
+  // mark them as unreachable in that case.
+
+  static intptr_t HeaderSize() {
+#if defined(DART_PRECOMPILED_RUNTIME)
+    if (FLAG_use_bare_instructions) {
+      UNREACHABLE();
+    }
+#endif
+    return Utils::RoundUp(sizeof(InstructionsLayout), kNonBarePayloadAlignment);
+  }
+
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(InstructionsLayout) ==
-           OFFSET_OF_RETURNED_VALUE(InstructionsLayout, data));
+    ASSERT_EQUAL(sizeof(InstructionsLayout),
+                 OFFSET_OF_RETURNED_VALUE(InstructionsLayout, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t size) {
-    return Utils::RoundUp(HeaderSize() + size, kObjectAlignment);
-  }
-
-  static intptr_t HeaderSize() {
-    return Utils::RoundUp(sizeof(InstructionsLayout), kWordSize);
+#if defined(DART_PRECOMPILED_RUNTIME)
+    if (FLAG_use_bare_instructions) {
+      UNREACHABLE();
+    }
+#endif
+    return RoundedAllocationSize(HeaderSize() + size);
   }
 
   static InstructionsPtr FromPayloadStart(uword payload_start) {
+#if defined(DART_PRECOMPILED_RUNTIME)
+    if (FLAG_use_bare_instructions) {
+      UNREACHABLE();
+    }
+#endif
     return static_cast<InstructionsPtr>(payload_start - HeaderSize() +
                                         kHeapObjectTag);
   }
@@ -5592,7 +5621,8 @@
   }
 
   static intptr_t HeaderSize() {
-    return Utils::RoundUp(sizeof(InstructionsSectionLayout), kWordSize);
+    return Utils::RoundUp(sizeof(InstructionsSectionLayout),
+                          Instructions::kBarePayloadAlignment);
   }
 
  private:
@@ -5645,15 +5675,14 @@
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = kMaxInt32 / kBytesPerElement;
 
+  static intptr_t HeaderSize() { return sizeof(PcDescriptorsLayout); }
   static intptr_t UnroundedSize(PcDescriptorsPtr desc) {
     return UnroundedSize(desc->ptr()->length_);
   }
-  static intptr_t UnroundedSize(intptr_t len) {
-    return sizeof(PcDescriptorsLayout) + len;
-  }
+  static intptr_t UnroundedSize(intptr_t len) { return HeaderSize() + len; }
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(PcDescriptorsLayout) ==
-           OFFSET_OF_RETURNED_VALUE(PcDescriptorsLayout, data));
+    ASSERT_EQUAL(sizeof(PcDescriptorsLayout),
+                 OFFSET_OF_RETURNED_VALUE(PcDescriptorsLayout, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t len) {
@@ -5784,15 +5813,14 @@
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = kMaxInt32 / kBytesPerElement;
 
+  static intptr_t HeaderSize() { return sizeof(CodeSourceMapLayout); }
   static intptr_t UnroundedSize(CodeSourceMapPtr map) {
     return UnroundedSize(map->ptr()->length_);
   }
-  static intptr_t UnroundedSize(intptr_t len) {
-    return sizeof(CodeSourceMapLayout) + len;
-  }
+  static intptr_t UnroundedSize(intptr_t len) { return HeaderSize() + len; }
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(CodeSourceMapLayout) ==
-           OFFSET_OF_RETURNED_VALUE(CodeSourceMapLayout, data));
+    ASSERT_EQUAL(sizeof(CodeSourceMapLayout),
+                 OFFSET_OF_RETURNED_VALUE(CodeSourceMapLayout, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t len) {
@@ -5849,15 +5877,16 @@
   bool Equals(const CompressedStackMaps* other) const { return Equals(*other); }
   intptr_t Hashcode() const;
 
+  static intptr_t HeaderSize() { return sizeof(CompressedStackMapsLayout); }
   static intptr_t UnroundedSize(CompressedStackMapsPtr maps) {
     return UnroundedSize(CompressedStackMaps::PayloadSizeOf(maps));
   }
   static intptr_t UnroundedSize(intptr_t length) {
-    return sizeof(CompressedStackMapsLayout) + length;
+    return HeaderSize() + length;
   }
   static intptr_t InstanceSize() {
-    ASSERT(sizeof(CompressedStackMapsLayout) ==
-           OFFSET_OF_RETURNED_VALUE(CompressedStackMapsLayout, data));
+    ASSERT_EQUAL(sizeof(CompressedStackMapsLayout),
+                 OFFSET_OF_RETURNED_VALUE(CompressedStackMapsLayout, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t length) {
diff --git a/runtime/vm/raw_object.h b/runtime/vm/raw_object.h
index 82b9df0..cb853c6 100644
--- a/runtime/vm/raw_object.h
+++ b/runtime/vm/raw_object.h
@@ -23,6 +23,17 @@
 #include "vm/token.h"
 #include "vm/token_position.h"
 
+// Currently we have two different axes for offset generation:
+//
+//  * Target architecture
+//  * DART_PRECOMPILED_RUNTIME (i.e, AOT vs. JIT)
+//
+// That is, fields in ObjectLayout and its subclasses should only be included or
+// excluded conditionally based on these factors. Otherwise, the generated
+// offsets can be wrong (which should be caught by offset checking in dart.cc).
+//
+// TODO(dartbug.com/43646): Add DART_PRECOMPILER as another axis.
+
 namespace dart {
 
 // For now there are no compressed pointers.
diff --git a/sdk/lib/_internal/allowed_experiments.json b/sdk/lib/_internal/allowed_experiments.json
index c967d66..aadacfe 100644
--- a/sdk/lib/_internal/allowed_experiments.json
+++ b/sdk/lib/_internal/allowed_experiments.json
@@ -70,12 +70,21 @@
     "flutter_goldens_client": {
       "experimentSet": "nullSafety"
     },
+    "http": {
+      "experimentSet": "nullSafety"
+    },
+    "http_parser": {
+      "experimentSet": "nullSafety"
+    },
     "intl": {
       "experimentSet": "nullSafety"
     },
     "js": {
       "experimentSet": "nullSafety"
     },
+    "logging": {
+      "experimentSet": "nullSafety"
+    },
     "matcher": {
       "experimentSet": "nullSafety"
     },
diff --git a/tests/co19/co19-co19.status b/tests/co19/co19-co19.status
index f93ebee..f764342 100644
--- a/tests/co19/co19-co19.status
+++ b/tests/co19/co19-co19.status
@@ -26,7 +26,6 @@
 Language/Statements/Expression_Statements/syntax_t06: Skip # Type aliases are not fully implemented
 Language/Types/Type_Aliases/built-in_types_t11: Skip # Triple shift is not implemented yet
 LanguageFeatures/Extension-methods/explicit_extension_member_invocation_A15_t09: Skip # Triple shift is not implemented yet
-LanguageFeatures/Instantiate-to-bound/class/static/*: Skip # Not migrated to NNBD
 LanguageFeatures/Instantiate-to-bound/nonfunction_typedef/static/*: Skip # Not migrated to NNBD
 LanguageFeatures/Instantiate-to-bound/typedef/static/*: Skip # Not migrated to NNBD
 LanguageFeatures/Simple-bounds/dynamic/type-aliases/*: Skip # Type aliases are not fully implemented
diff --git a/tools/VERSION b/tools/VERSION
index b629cdf0..e706233 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 11
 PATCH 0
-PRERELEASE 189
+PRERELEASE 190
 PRERELEASE_PATCH 0
\ No newline at end of file
diff --git a/tools/bots/test_matrix.json b/tools/bots/test_matrix.json
index 605c4d5..1115d5e 100644
--- a/tools/bots/test_matrix.json
+++ b/tools/bots/test_matrix.json
@@ -891,8 +891,7 @@
           "testRunner": true,
           "arguments": [
             "pkg/front_end/test/unit_test_suites.dart",
-            "-ncfe-unittest-asserts-${mode}-${system}",
-            "--verbose"
+            "-ncfe-unittest-asserts-${mode}-${system}"
           ]
         }
       ]
diff --git a/tools/run_offsets_extractor.sh b/tools/run_offsets_extractor.sh
index 8675fea..d3fd6ec9 100755
--- a/tools/run_offsets_extractor.sh
+++ b/tools/run_offsets_extractor.sh
@@ -14,13 +14,17 @@
   exit 1
 fi
 
-# We're regenerating the file, but we want to keep all the comments etc at the
-# top of the file. So just delete everything after the first "#if defined".
-LINE=$(grep "#if " "$FILE" -n | head -n 1 | sed "s/^\([0-9]*\):.*/\1/")
 TEMP="${FILE}.temp"
 TEMP_HEADER="${FILE}.header.temp"
 TEMP_JIT="${FILE}.jit.temp"
 TEMP_AOT="${FILE}.aot.temp"
+
+# Remove old temp files if the previous run was stopped prematurely.
+rm -rf "${TEMP}" "${TEMP_HEADER}" "${TEMP_JIT}" "${TEMP_AOT}"
+
+# We're regenerating the file, but we want to keep all the comments etc at the
+# top of the file. So just delete everything after the first "#if defined".
+LINE=$(grep "#if " "$FILE" -n | head -n 1 | sed "s/^\([0-9]*\):.*/\1/")
 head -n $(expr $LINE - 1) "$FILE" >"$TEMP_HEADER"
 
 # Run offsets_extractor for every architecture and append the results.