diff --git a/.dart_tool/package_config.json b/.dart_tool/package_config.json
index 8839a05..e059e45 100644
--- a/.dart_tool/package_config.json
+++ b/.dart_tool/package_config.json
@@ -259,6 +259,12 @@
       "languageVersion": "2.13"
     },
     {
+      "name": "dds_service_extensions",
+      "rootUri": "../pkg/dds_service_extensions",
+      "packageUri": "lib/",
+      "languageVersion": "2.13"
+    },
+    {
       "name": "dev_compiler",
       "rootUri": "../pkg/dev_compiler",
       "packageUri": "lib/",
diff --git a/.packages b/.packages
index f5ea5bc..e8855d6 100644
--- a/.packages
+++ b/.packages
@@ -38,6 +38,7 @@
 dartdev:pkg/dartdev/lib
 dartdoc:third_party/pkg/dartdoc/lib
 dds:pkg/dds/lib
+dds_service_extensions:pkg/dds_service_extensions/lib
 dev_compiler:pkg/dev_compiler/lib
 devtools_server:third_party/devtools/devtools_server/lib
 devtools_shared:third_party/devtools/devtools_shared/lib
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 67b4b8f..039502f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,12 +1,17 @@
-## 2.16.0
+## 2.17.0
 
 ### Core libraries
 
 #### `dart:core`
 
-- **Breaking Change** [#47653](https://github.com/dart-lang/sdk/issues/47653):
-  On Windows, `Directory.rename` will no longer delete a directory if
-  `newPath` specifies one. Instead, a `FileSystemException` will be thrown.
+- Add `Finalizer` and `WeakReference` which can potentially detect when
+  objects are "garbage collected".
+
+## 2.16.0
+
+### Core libraries
+
+#### `dart:core`
 
 - Add `Error.throwWithStackTrace` which can `throw` an
   error with an existing stack trace, instead of creating
@@ -19,6 +24,10 @@
 
 #### `dart:io`
 
+- **Breaking Change** [#47653](https://github.com/dart-lang/sdk/issues/47653):
+On Windows, `Directory.rename` will no longer delete a directory if
+`newPath` specifies one. Instead, a `FileSystemException` will be thrown.
+
 - **Breaking Change** [#47769](https://github.com/dart-lang/sdk/issues/47769):
 The `Platform.packageRoot` API has been removed. It had been marked deprecated
 in 2018, as it doesn't work with any Dart 2.x release.
diff --git a/DEPS b/DEPS
index e0dda5f..3497c49 100644
--- a/DEPS
+++ b/DEPS
@@ -59,6 +59,8 @@
   # Checkout extra javascript engines for testing or benchmarking.
   # d8, the V8 shell, is always checked out.
   "checkout_javascript_engines": False,
+  "d8_tag": "version:9.9.3",
+  "jsshell_tag": "version:95.0",
 
   # As Flutter does, we use Fuchsia's GN and Clang toolchain. These revision
   # should be kept up to date with the revisions pulled by the Flutter engine.
@@ -107,9 +109,8 @@
   # For more details, see https://github.com/dart-lang/sdk/issues/30164
   "dart_style_rev": "08b0294d0a500d5c02168ef57dcb8868d0c3cb48",
 
-  "dartdoc_rev" : "11c4b3c9723bfa7155efcf0fef02329233a6381d",
+  "dartdoc_rev" : "66ee9a81b3bab35adcda18274b7d69567c98c3c6",
   "devtools_rev" : "85932bb66aa782c4b2c528be7718960bf256ffb7",
-  "jsshell_tag": "version:88.0",
   "ffi_rev": "4dd32429880a57b64edaf54c9d5af8a9fa9a4ffb",
   "fixnum_rev": "16d3890c6dc82ca629659da1934e412292508bba",
   "file_rev": "0e09370f581ab6388d46fda4cdab66638c0171a1",
@@ -213,7 +214,7 @@
   Var("dart_root") + "/third_party/d8": {
       "packages": [{
           "package": "dart/d8",
-          "version": "version:9.1.269",
+          "version": Var("d8_tag"),
       }],
       "dep_type": "cipd",
   },
@@ -225,15 +226,6 @@
       "condition": "checkout_javascript_engines",
       "dep_type": "cipd",
   },
-  # TODO(b/186078239): remove this copy to the old location
-  Var("dart_root") + "/third_party/firefox_jsshell/linux/jsshell": {
-      "packages": [{
-          "package": "dart/third_party/jsshell/linux-amd64",
-          "version": Var("jsshell_tag"),
-      }],
-      "condition": "checkout_javascript_engines",
-      "dep_type": "cipd",
-  },
   Var("dart_root") + "/third_party/devtools": {
       "packages": [{
           "package": "dart/third_party/flutter/devtools",
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/api/code.dart b/pkg/_fe_analyzer_shared/lib/src/macros/api/code.dart
index 89f169f..1486d1c 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/api/code.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/api/code.dart
@@ -7,10 +7,14 @@
 /// The base class representing an arbitrary chunk of Dart code, which may or
 /// may not be syntactically or semantically valid yet.
 class Code {
-  /// All the chunks of [Code] or raw [String]s that comprise this [Code]
-  /// object.
+  /// All the chunks of [Code], raw [String]s, or [TypeAnnotation]s that
+  /// comprise this [Code] object.
   final List<Object> parts;
 
+  /// Can be used to more efficiently detect the kind of code, avoiding is
+  /// checks and enabling switch statements.
+  CodeKind get kind => CodeKind.raw;
+
   Code.fromString(String code) : parts = [code];
 
   Code.fromParts(this.parts);
@@ -18,6 +22,9 @@
 
 /// A piece of code representing a syntactically valid declaration.
 class DeclarationCode extends Code {
+  @override
+  CodeKind get kind => CodeKind.declaration;
+
   DeclarationCode.fromString(String code) : super.fromString(code);
 
   DeclarationCode.fromParts(List<Object> parts) : super.fromParts(parts);
@@ -27,6 +34,9 @@
 ///
 /// Should not include any trailing commas,
 class ElementCode extends Code {
+  @override
+  CodeKind get kind => CodeKind.element;
+
   ElementCode.fromString(String code) : super.fromString(code);
 
   ElementCode.fromParts(List<Object> parts) : super.fromParts(parts);
@@ -34,6 +44,9 @@
 
 /// A piece of code representing a syntactically valid expression.
 class ExpressionCode extends Code {
+  @override
+  CodeKind get kind => CodeKind.expression;
+
   ExpressionCode.fromString(String code) : super.fromString(code);
 
   ExpressionCode.fromParts(List<Object> parts) : super.fromParts(parts);
@@ -46,6 +59,9 @@
 ///
 /// Both arrow and block function bodies are allowed.
 class FunctionBodyCode extends Code {
+  @override
+  CodeKind get kind => CodeKind.functionBody;
+
   FunctionBodyCode.fromString(String code) : super.fromString(code);
 
   FunctionBodyCode.fromParts(List<Object> parts) : super.fromParts(parts);
@@ -53,6 +69,9 @@
 
 /// A piece of code representing a syntactically valid identifier.
 class IdentifierCode extends Code {
+  @override
+  CodeKind get kind => CodeKind.identifier;
+
   IdentifierCode.fromString(String code) : super.fromString(code);
 
   IdentifierCode.fromParts(List<Object> parts) : super.fromParts(parts);
@@ -62,6 +81,9 @@
 ///
 /// This should not include any trailing commas.
 class NamedArgumentCode extends Code {
+  @override
+  CodeKind get kind => CodeKind.namedArgument;
+
   NamedArgumentCode.fromString(String code) : super.fromString(code);
 
   NamedArgumentCode.fromParts(List<Object> parts) : super.fromParts(parts);
@@ -77,6 +99,9 @@
 /// construct and combine these together in a way that creates valid parameter
 /// lists.
 class ParameterCode extends Code {
+  @override
+  CodeKind get kind => CodeKind.parameter;
+
   ParameterCode.fromString(String code) : super.fromString(code);
 
   ParameterCode.fromParts(List<Object> parts) : super.fromParts(parts);
@@ -86,6 +111,9 @@
 ///
 /// Should always end with a semicolon.
 class StatementCode extends Code {
+  @override
+  CodeKind get kind => CodeKind.statement;
+
   StatementCode.fromString(String code) : super.fromString(code);
 
   StatementCode.fromParts(List<Object> parts) : super.fromParts(parts);
@@ -102,3 +130,15 @@
         last,
       ];
 }
+
+enum CodeKind {
+  raw,
+  declaration,
+  element,
+  expression,
+  functionBody,
+  identifier,
+  namedArgument,
+  parameter,
+  statement,
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart b/pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart
index e892296..318219b 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart
@@ -14,6 +14,10 @@
 
   /// A [Code] object representation of this type annotation.
   Code get code;
+
+  /// Allows you to check the kind of a [TypeAnnotation] in a switch statement,
+  /// and without `is` checks.
+  TypeAnnotationKind get kind;
 }
 
 /// The base class for function type declarations.
@@ -29,6 +33,9 @@
 
   /// The type parameters for this function.
   Iterable<TypeParameterDeclaration> get typeParameters;
+
+  @override
+  TypeAnnotationKind get kind => TypeAnnotationKind.functionType;
 }
 
 /// An unresolved reference to a type.
@@ -41,6 +48,9 @@
 
   /// The type arguments, if applicable.
   Iterable<TypeAnnotation> get typeArguments;
+
+  @override
+  TypeAnnotationKind get kind => TypeAnnotationKind.namedType;
 }
 
 /// The interface representing a resolved type.
@@ -65,9 +75,15 @@
 abstract class Declaration {
   /// The name of this declaration.
   String get name;
+
+  /// Allows you to check the kind of a [Declaration] in a switch statement,
+  /// and without `is` checks.
+  DeclarationKind get kind;
 }
 
 /// A declaration that defines a new type in the program.
+///
+/// See subtypes [ClassDeclaration] and [TypeAliasDeclaration].
 abstract class TypeDeclaration implements Declaration {
   /// The type parameters defined for this type declaration.
   Iterable<TypeParameterDeclaration> get typeParameters;
@@ -89,6 +105,9 @@
 /// Information about fields, methods, and constructors must be retrieved from
 /// the `builder` objects.
 abstract class ClassDeclaration implements TypeDeclaration {
+  @override
+  DeclarationKind get kind => DeclarationKind.clazz;
+
   /// Whether this class has an `abstract` modifier.
   bool get isAbstract;
 
@@ -108,8 +127,20 @@
   Iterable<TypeParameterDeclaration> get typeParameters;
 }
 
+/// Type alias introspection information.
+abstract class TypeAliasDeclaration extends TypeDeclaration {
+  @override
+  DeclarationKind get kind => DeclarationKind.typeAlias;
+
+  /// The type annotation this is an alias for.
+  TypeAnnotation get type;
+}
+
 /// Function introspection information.
 abstract class FunctionDeclaration implements Declaration {
+  @override
+  DeclarationKind get kind => DeclarationKind.function;
+
   /// Whether this function has an `abstract` modifier.
   bool get isAbstract;
 
@@ -137,6 +168,9 @@
 
 /// Method introspection information.
 abstract class MethodDeclaration implements FunctionDeclaration {
+  @override
+  DeclarationKind get kind => DeclarationKind.method;
+
   /// The class that defines this method.
   TypeAnnotation get definingClass;
 }
@@ -149,6 +183,9 @@
 
 /// Variable introspection information.
 abstract class VariableDeclaration implements Declaration {
+  @override
+  DeclarationKind get kind => DeclarationKind.variable;
+
   /// Whether this function has an `abstract` modifier.
   bool get isAbstract;
 
@@ -164,12 +201,18 @@
 
 /// Field introspection information ..
 abstract class FieldDeclaration implements VariableDeclaration {
+  @override
+  DeclarationKind get kind => DeclarationKind.field;
+
   /// The class that defines this method.
   TypeAnnotation get definingClass;
 }
 
 /// Parameter introspection information.
 abstract class ParameterDeclaration implements Declaration {
+  @override
+  DeclarationKind get kind => DeclarationKind.parameter;
+
   /// The type of this parameter.
   TypeAnnotation get type;
 
@@ -187,6 +230,28 @@
 
 /// Type parameter introspection information.
 abstract class TypeParameterDeclaration implements Declaration {
+  @override
+  DeclarationKind get kind => DeclarationKind.typeParameter;
+
   /// The bounds for this type parameter, if it has any.
   TypeAnnotation? get bounds;
 }
+
+// The kinds of type declarations.
+enum DeclarationKind {
+  clazz,
+  constructor,
+  field,
+  function,
+  method,
+  parameter,
+  typeAlias,
+  typeParameter,
+  variable,
+}
+
+// The kinds of type annotations.
+enum TypeAnnotationKind {
+  namedType,
+  functionType,
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart b/pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart
new file mode 100644
index 0000000..55ea8bd
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart
@@ -0,0 +1,143 @@
+// Copyright (c) 2022, 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.
+
+/// Generates a Dart program for a given macro, which can be compiled and then
+/// passed as a precompiled kernel file to `MacroExecutor.loadMacro`.
+String bootstrapMacroIsolate(
+    String macroImport, String macroName, List<String> constructorNames) {
+  StringBuffer constructorEntries = new StringBuffer(
+      "MacroClassIdentifierImpl(Uri.parse('$macroImport'), '$macroName'): {");
+  for (String constructor in constructorNames) {
+    constructorEntries.writeln("'$constructor': "
+        "$macroName.${constructor.isEmpty ? 'new' : constructor},");
+  }
+  constructorEntries.writeln('},');
+  return template
+      .replaceFirst(_importMarker, 'import \'$macroImport\';')
+      .replaceFirst(
+          _macroConstructorEntriesMarker, constructorEntries.toString());
+}
+
+const String _importMarker = '{{IMPORT}}';
+const String _macroConstructorEntriesMarker = '{{MACRO_CONSTRUCTOR_ENTRIES}}';
+
+const String template = '''
+import 'dart:async';
+import 'dart:isolate';
+
+import 'package:_fe_analyzer_shared/src/macros/executor_shared/response_impls.dart';
+import 'package:_fe_analyzer_shared/src/macros/executor_shared/serialization.dart';
+import 'package:_fe_analyzer_shared/src/macros/executor_shared/protocol.dart';
+import 'package:_fe_analyzer_shared/src/macros/executor.dart';
+import 'package:_fe_analyzer_shared/src/macros/api.dart';
+
+$_importMarker
+
+/// Entrypoint to be spawned with [Isolate.spawnUri].
+///
+/// Supports the client side of the macro expansion protocol.
+void main(_, SendPort sendPort) {
+  withSerializationMode(SerializationMode.client, () {
+    ReceivePort receivePort = new ReceivePort();
+    sendPort.send(receivePort.sendPort);
+    receivePort.listen((message) async {
+      var deserializer = JsonDeserializer(message as Iterable<Object?>)
+          ..moveNext();
+      var type = MessageType.values[deserializer.expectNum()];
+      var serializer = JsonSerializer();
+      switch (type) {
+        case MessageType.instantiateMacroRequest:
+          var request = InstantiateMacroRequest.deserialize(deserializer);
+          (await _instantiateMacro(request)).serialize(serializer);
+          break;
+        case MessageType.executeDefinitionsPhaseRequest:
+          var request = ExecuteDefinitionsPhaseRequest.deserialize(
+              deserializer,
+              ClientTypeResolver(),
+              ClientClassIntrospector(),
+              ClientTypeDeclarationsResolver());
+          (await _executeDefinitionsPhase(request)).serialize(serializer);
+          break;
+        default:
+          throw new StateError('Unhandled event type \$type');
+      }
+      sendPort.send(serializer.result);
+    });
+  });
+}
+
+/// Maps macro identifiers to constructors.
+final _macroConstructors = <MacroClassIdentifierImpl, Map<String, Macro Function()>>{
+  $_macroConstructorEntriesMarker
+};
+
+/// Maps macro instance identifiers to instances.
+final _macroInstances = <MacroInstanceIdentifierImpl, Macro>{};
+
+/// Handles [InstantiateMacroRequest]s.
+Future<SerializableResponse> _instantiateMacro(
+    InstantiateMacroRequest request) async {
+  try {
+    var constructors = _macroConstructors[request.macroClass];
+    if (constructors == null) {
+      throw new ArgumentError('Unrecognized macro class \${request.macroClass}');
+    }
+    var constructor = constructors[request.constructorName];
+    if (constructor == null) {
+      throw new ArgumentError(
+          'Unrecognized constructor name "\${request.constructorName}" for '
+          'macro class "\${request.macroClass}".');
+    }
+
+    var instance = Function.apply(constructor, request.arguments.positional, {
+      for (MapEntry<String, Object?> entry in request.arguments.named.entries)
+        new Symbol(entry.key): entry.value,
+    }) as Macro;
+    var identifier = new MacroInstanceIdentifierImpl();
+    _macroInstances[identifier] = instance;
+    return new SerializableResponse(
+        responseType: MessageType.macroInstanceIdentifier,
+        response: identifier,
+        requestId: request.id);
+  } catch (e) {
+    return new SerializableResponse(
+      responseType: MessageType.error,
+      error: e.toString(),
+      requestId: request.id);
+  }
+}
+
+Future<SerializableResponse> _executeDefinitionsPhase(
+    ExecuteDefinitionsPhaseRequest request) async {
+  try {
+    Macro? instance = _macroInstances[request.macro];
+    if (instance == null) {
+      throw new StateError('Unrecognized macro instance \${request.macro}\\n'
+          'Known instances: \$_macroInstances)');
+    }
+    Declaration declaration = request.declaration;
+    if (instance is FunctionDefinitionMacro &&
+        declaration is FunctionDeclaration) {
+      FunctionDefinitionBuilderImpl builder = new FunctionDefinitionBuilderImpl(
+          declaration,
+          request.typeResolver,
+          request.typeDeclarationResolver,
+          request.classIntrospector);
+      await instance.buildDefinitionForFunction(declaration, builder);
+      return new SerializableResponse(
+          responseType: MessageType.macroExecutionResult,
+          response: builder.result,
+          requestId: request.id);
+    } else {
+      throw new UnsupportedError(
+          ('Only FunctionDefinitionMacros are supported currently'));
+    }
+  } catch (e) {
+    return new SerializableResponse(
+      responseType: MessageType.error,
+      error: e.toString(),
+      requestId: request.id);
+  }
+}
+''';
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor.dart
index d4d248d..38a9f4b 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/executor.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor.dart
@@ -3,13 +3,17 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'api.dart';
+import 'bootstrap.dart'; // For doc comments only.
+import 'executor_shared/serialization.dart';
 
 /// Exposes a platform specific [MacroExecutor], through a top level
 /// `Future<MacroExecutor> start()` function.
 ///
 /// TODO: conditionally load isolate_mirrors_executor.dart once conditional
 /// imports of mirrors are supported in AOT (issue #48057).
-import 'fake_executor/fake_executor.dart' as executor_impl show start;
+import 'fake_executor/fake_executor.dart'
+    if (dart.library.isolate) 'isolated_executor/isolated_executor.dart'
+    as executor_impl show start;
 
 /// The interface used by Dart language implementations, in order to load
 /// and execute macros, as well as produce library augmentations from those
@@ -22,6 +26,9 @@
   /// Returns a platform specific [MacroExecutor]. On unsupported platforms this
   /// will be a fake executor object, which will throw an [UnsupportedError] if
   /// used.
+  ///
+  /// Note that some implementations will also require calls to [loadMacro]
+  /// to pass a `precompiledKernelUri`.
   static Future<MacroExecutor> start() => executor_impl.start();
 
   /// Invoked when an implementation discovers a new macro definition in a
@@ -32,8 +39,17 @@
   /// [MacroInstanceIdentifier]s given for this macro will be invalid after
   /// that point and should be discarded.
   ///
+  /// The [precompiledKernelUri] if passed must point to a kernel program for
+  /// the given macro. A bootstrap Dart program can be generated with the
+  /// [bootstrapMacroIsolate] function, and the result should be compiled to
+  /// kernel and passed here.
+  ///
+  /// Some implementations may require [precompiledKernelUri] to be passed, and
+  /// will throw an [UnsupportedError] if it is not.
+  ///
   /// Throws an exception if the macro fails to load.
-  Future<MacroClassIdentifier> loadMacro(Uri library, String name);
+  Future<MacroClassIdentifier> loadMacro(Uri library, String name,
+      {Uri? precompiledKernelUri});
 
   /// Creates an instance of [macroClass] in the executor, and returns an
   /// identifier for that instance.
@@ -81,31 +97,143 @@
 ///
 /// All argument instances must be of type [Code] or a built-in value type that
 /// is serializable (num, bool, String, null, etc).
-class Arguments {
+class Arguments implements Serializable {
   final List<Object?> positional;
 
   final Map<String, Object?> named;
 
   Arguments(this.positional, this.named);
+
+  factory Arguments.deserialize(Deserializer deserializer) {
+    deserializer
+      ..moveNext()
+      ..expectList();
+    List<Object?> positionalArgs = [
+      for (bool hasNext = deserializer.moveNext();
+          hasNext;
+          hasNext = deserializer.moveNext())
+        _deserializeArg(deserializer, alreadyMoved: true),
+    ];
+    deserializer
+      ..moveNext()
+      ..expectList();
+    Map<String, Object?> namedArgs = {
+      for (bool hasNext = deserializer.moveNext();
+          hasNext;
+          hasNext = deserializer.moveNext())
+        deserializer.expectString(): _deserializeArg(deserializer),
+    };
+    return new Arguments(positionalArgs, namedArgs);
+  }
+
+  static Object? _deserializeArg(Deserializer deserializer,
+      {bool alreadyMoved = false}) {
+    if (!alreadyMoved) deserializer.moveNext();
+    _ArgumentKind kind = _ArgumentKind.values[deserializer.expectNum()];
+    switch (kind) {
+      case _ArgumentKind.nil:
+        return null;
+      case _ArgumentKind.string:
+        deserializer.moveNext();
+        return deserializer.expectString();
+      case _ArgumentKind.bool:
+        deserializer.moveNext();
+        return deserializer.expectBool();
+      case _ArgumentKind.num:
+        deserializer.moveNext();
+        return deserializer.expectNum();
+      case _ArgumentKind.list:
+        deserializer.moveNext();
+        deserializer.expectList();
+        return [
+          for (bool hasNext = deserializer.moveNext();
+              hasNext;
+              hasNext = deserializer.moveNext())
+            _deserializeArg(deserializer, alreadyMoved: true),
+        ];
+      case _ArgumentKind.map:
+        deserializer.moveNext();
+        deserializer.expectList();
+        return {
+          for (bool hasNext = deserializer.moveNext();
+              hasNext;
+              hasNext = deserializer.moveNext())
+            _deserializeArg(deserializer, alreadyMoved: true):
+                _deserializeArg(deserializer),
+        };
+    }
+  }
+
+  void serialize(Serializer serializer) {
+    serializer.startList();
+    for (Object? arg in positional) {
+      _serializeArg(arg, serializer);
+    }
+    serializer.endList();
+
+    serializer.startList();
+    for (MapEntry<String, Object?> arg in named.entries) {
+      serializer.addString(arg.key);
+      _serializeArg(arg.value, serializer);
+    }
+    serializer.endList();
+  }
+
+  static void _serializeArg(Object? arg, Serializer serializer) {
+    if (arg == null) {
+      serializer.addNum(_ArgumentKind.nil.index);
+    } else if (arg is String) {
+      serializer
+        ..addNum(_ArgumentKind.string.index)
+        ..addString(arg);
+    } else if (arg is num) {
+      serializer
+        ..addNum(_ArgumentKind.num.index)
+        ..addNum(arg);
+    } else if (arg is bool) {
+      serializer
+        ..addNum(_ArgumentKind.bool.index)
+        ..addBool(arg);
+    } else if (arg is List) {
+      serializer
+        ..addNum(_ArgumentKind.list.index)
+        ..startList();
+      for (Object? item in arg) {
+        _serializeArg(item, serializer);
+      }
+      serializer.endList();
+    } else if (arg is Map) {
+      serializer
+        ..addNum(_ArgumentKind.map.index)
+        ..startList();
+      for (MapEntry<Object?, Object?> entry in arg.entries) {
+        _serializeArg(entry.key, serializer);
+        _serializeArg(entry.value, serializer);
+      }
+      serializer.endList();
+    } else {
+      throw new UnsupportedError('Unsupported argument type $arg');
+    }
+  }
 }
 
 /// An opaque identifier for a macro class, retrieved by
 /// [MacroExecutor.loadMacro].
 ///
 /// Used to execute or reload this macro in the future.
-abstract class MacroClassIdentifier {}
+abstract class MacroClassIdentifier implements Serializable {}
 
 /// An opaque identifier for an instance of a macro class, retrieved by
 /// [MacroExecutor.instantiateMacro].
 ///
 /// Used to execute or reload this macro in the future.
-abstract class MacroInstanceIdentifier {}
+abstract class MacroInstanceIdentifier implements Serializable {}
 
 /// A summary of the results of running a macro in a given phase.
 ///
 /// All modifications are expressed in terms of library augmentation
 /// declarations.
-abstract class MacroExecutionResult {
+abstract class MacroExecutionResult implements Serializable {
   /// Any library imports that should be added to support the code used in
   /// the augmentations.
   Iterable<DeclarationCode> get imports;
@@ -125,3 +253,6 @@
   /// This phase allows augmenting existing declarations.
   definitions,
 }
+
+/// Used for serializing and deserializing arguments.
+enum _ArgumentKind { string, bool, num, list, map, nil }
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/introspection_impls.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/introspection_impls.dart
new file mode 100644
index 0000000..e237127
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/introspection_impls.dart
@@ -0,0 +1,181 @@
+// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import '../api.dart';
+
+abstract class TypeAnnotationImpl implements TypeAnnotation {
+  final bool isNullable;
+
+  TypeAnnotationImpl({required this.isNullable});
+}
+
+class NamedTypeAnnotationImpl extends TypeAnnotationImpl
+    implements NamedTypeAnnotation {
+  @override
+  Code get code => new Code.fromParts([
+        name,
+        if (typeArguments.isNotEmpty) ...[
+          '<',
+          for (TypeAnnotation arg in typeArguments) ...[arg, ','],
+          '>',
+        ],
+        if (isNullable) '?',
+      ]);
+
+  @override
+  final String name;
+
+  @override
+  final List<TypeAnnotation> typeArguments;
+
+  @override
+  TypeAnnotationKind get kind => TypeAnnotationKind.namedType;
+
+  NamedTypeAnnotationImpl({
+    required bool isNullable,
+    required this.name,
+    required this.typeArguments,
+  }) : super(isNullable: isNullable);
+}
+
+class FunctionTypeAnnotationImpl extends TypeAnnotationImpl
+    implements FunctionTypeAnnotation {
+  @override
+  Code get code => new Code.fromParts([
+        returnType,
+        'Function',
+        if (typeParameters.isNotEmpty) ...[
+          '<',
+          for (TypeParameterDeclaration arg in typeParameters) ...[
+            arg.name,
+            if (arg.bounds != null) ...[' extends ', arg.bounds!],
+            ','
+          ],
+          '>',
+        ],
+        '(',
+        for (ParameterDeclaration positional in positionalParameters) ...[
+          positional.type,
+          ' ${positional.name}',
+        ],
+        if (namedParameters.isNotEmpty) ...[
+          '{',
+          for (ParameterDeclaration named in namedParameters) ...[
+            named.type,
+            ' ${named.name}',
+          ],
+          '}',
+        ],
+        ')',
+        if (isNullable) '?',
+      ]);
+
+  @override
+  final List<ParameterDeclaration> namedParameters;
+
+  @override
+  final List<ParameterDeclaration> positionalParameters;
+
+  @override
+  final TypeAnnotation returnType;
+
+  @override
+  final List<TypeParameterDeclaration> typeParameters;
+
+  @override
+  TypeAnnotationKind get kind => TypeAnnotationKind.functionType;
+
+  FunctionTypeAnnotationImpl({
+    required bool isNullable,
+    required this.namedParameters,
+    required this.positionalParameters,
+    required this.returnType,
+    required this.typeParameters,
+  }) : super(isNullable: isNullable);
+}
+
+class ParameterDeclarationImpl implements ParameterDeclaration {
+  @override
+  final String name;
+
+  @override
+  final Code? defaultValue;
+
+  @override
+  final bool isNamed;
+
+  @override
+  final bool isRequired;
+
+  @override
+  final TypeAnnotation type;
+
+  @override
+  DeclarationKind get kind => DeclarationKind.parameter;
+
+  ParameterDeclarationImpl({
+    required this.name,
+    required this.defaultValue,
+    required this.isNamed,
+    required this.isRequired,
+    required this.type,
+  });
+}
+
+class TypeParameterDeclarationImpl implements TypeParameterDeclaration {
+  @override
+  final String name;
+
+  @override
+  final TypeAnnotation? bounds;
+
+  @override
+  DeclarationKind get kind => DeclarationKind.typeParameter;
+
+  TypeParameterDeclarationImpl({required this.name, required this.bounds});
+}
+
+class FunctionDeclarationImpl implements FunctionDeclaration {
+  @override
+  final String name;
+
+  @override
+  final bool isAbstract;
+
+  @override
+  final bool isExternal;
+
+  @override
+  final bool isGetter;
+
+  @override
+  final bool isSetter;
+
+  @override
+  final List<ParameterDeclaration> namedParameters;
+
+  @override
+  final List<ParameterDeclaration> positionalParameters;
+
+  @override
+  final TypeAnnotation returnType;
+
+  @override
+  final List<TypeParameterDeclaration> typeParameters;
+
+  @override
+  DeclarationKind get kind => DeclarationKind.function;
+
+  FunctionDeclarationImpl({
+    required this.name,
+    required this.isAbstract,
+    required this.isExternal,
+    required this.isGetter,
+    required this.isSetter,
+    required this.namedParameters,
+    required this.positionalParameters,
+    required this.returnType,
+    required this.typeParameters,
+  });
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/protocol.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/protocol.dart
new file mode 100644
index 0000000..3dcc455
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/protocol.dart
@@ -0,0 +1,263 @@
+// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// Defines the objects used for communication between the macro executor and
+/// the isolate or process doing the work of macro loading and execution.
+library _fe_analyzer_shared.src.macros.executor_shared.protocol;
+
+import '../executor.dart';
+import '../api.dart';
+import '../executor_shared/response_impls.dart';
+import 'serialization.dart';
+import 'serialization_extensions.dart';
+
+/// Base class all requests extend, provides a unique id for each request.
+abstract class Request implements Serializable {
+  final int id;
+
+  Request({int? id}) : this.id = id ?? _next++;
+
+  Request.deserialize(Deserializer deserializer)
+      : id = (deserializer..moveNext()).expectNum();
+
+  void serialize(Serializer serializer) => serializer.addNum(id);
+
+  static int _next = 0;
+}
+
+/// A generic response object that contains either a response or an error, and
+/// a unique ID.
+class Response {
+  final Object? response;
+  final Object? error;
+  final int requestId;
+
+  Response({this.response, this.error, required this.requestId})
+      : assert(response != null || error != null),
+        assert(response == null || error == null);
+}
+
+/// A serializable [Response], contains the message type as an enum.
+class SerializableResponse implements Response, Serializable {
+  final Serializable? response;
+  final MessageType responseType;
+  final String? error;
+  final int requestId;
+
+  SerializableResponse({
+    this.error,
+    required this.requestId,
+    this.response,
+    required this.responseType,
+  })  : assert(response != null || error != null),
+        assert(response == null || error == null);
+
+  factory SerializableResponse.deserialize(Deserializer deserializer) {
+    deserializer.moveNext();
+    MessageType responseType = MessageType.values[deserializer.expectNum()];
+    Serializable? response;
+    String? error;
+    switch (responseType) {
+      case MessageType.error:
+        deserializer.moveNext();
+        error = deserializer.expectString();
+        break;
+      case MessageType.macroClassIdentifier:
+        response = new MacroClassIdentifierImpl.deserialize(deserializer);
+        break;
+      case MessageType.macroInstanceIdentifier:
+        response = new MacroInstanceIdentifierImpl.deserialize(deserializer);
+        break;
+      case MessageType.macroExecutionResult:
+        response = new MacroExecutionResultImpl.deserialize(deserializer);
+        break;
+      default:
+        throw new StateError('Unexpected response type $responseType');
+    }
+
+    return new SerializableResponse(
+        responseType: responseType,
+        response: response,
+        error: error,
+        requestId: (deserializer..moveNext()).expectNum());
+  }
+
+  void serialize(Serializer serializer) {
+    serializer.addNum(responseType.index);
+    if (response != null) {
+      response!.serialize(serializer);
+    } else if (error != null) {
+      serializer.addString(error!.toString());
+    }
+    serializer.addNum(requestId);
+  }
+}
+
+/// A request to load a macro in this isolate.
+class LoadMacroRequest extends Request {
+  final Uri library;
+  final String name;
+
+  LoadMacroRequest(this.library, this.name);
+
+  LoadMacroRequest.deserialize(Deserializer deserializer)
+      : library = Uri.parse((deserializer..moveNext()).expectString()),
+        name = (deserializer..moveNext()).expectString(),
+        super.deserialize(deserializer);
+
+  @override
+  void serialize(Serializer serializer) {
+    serializer
+      ..addNum(MessageType.loadMacroRequest.index)
+      ..addString(library.toString())
+      ..addString(name);
+    super.serialize(serializer);
+  }
+}
+
+/// A request to instantiate a macro instance.
+class InstantiateMacroRequest extends Request {
+  final MacroClassIdentifier macroClass;
+  final String constructorName;
+  final Arguments arguments;
+
+  InstantiateMacroRequest(
+      this.macroClass, this.constructorName, this.arguments);
+
+  InstantiateMacroRequest.deserialize(Deserializer deserializer)
+      : macroClass = new MacroClassIdentifierImpl.deserialize(deserializer),
+        constructorName = (deserializer..moveNext()).expectString(),
+        arguments = new Arguments.deserialize(deserializer),
+        super.deserialize(deserializer);
+
+  @override
+  void serialize(Serializer serializer) {
+    serializer.addNum(MessageType.instantiateMacroRequest.index);
+    macroClass.serialize(serializer);
+    serializer.addString(constructorName);
+    arguments.serialize(serializer);
+    super.serialize(serializer);
+  }
+}
+
+/// A request to execute a macro on a particular declaration in the definition
+/// phase.
+class ExecuteDefinitionsPhaseRequest extends Request {
+  final MacroInstanceIdentifier macro;
+  final Declaration declaration;
+
+  /// Client/Server specific implementation, not serialized.
+  final TypeResolver typeResolver;
+
+  /// Client/Server specific implementation, not serialized.
+  final ClassIntrospector classIntrospector;
+
+  /// Client/Server specific implementation, not serialized.
+  final TypeDeclarationResolver typeDeclarationResolver;
+
+  ExecuteDefinitionsPhaseRequest(this.macro, this.declaration,
+      this.typeResolver, this.classIntrospector, this.typeDeclarationResolver);
+
+  /// When deserializing we have already consumed the message type, so we don't
+  /// consume it again.
+  ExecuteDefinitionsPhaseRequest.deserialize(Deserializer deserializer,
+      this.typeResolver, this.classIntrospector, this.typeDeclarationResolver)
+      : macro = new MacroInstanceIdentifierImpl.deserialize(deserializer),
+        declaration = (deserializer..moveNext()).expectDeclaration(),
+        super.deserialize(deserializer);
+
+  void serialize(Serializer serializer) {
+    serializer.addNum(MessageType.executeDefinitionsPhaseRequest.index);
+    macro.serialize(serializer);
+    declaration.serialize(serializer);
+    super.serialize(serializer);
+  }
+}
+
+/// A request to reflect on a type annotation
+class ReflectTypeRequest extends Request {
+  final TypeAnnotation typeAnnotation;
+
+  ReflectTypeRequest(this.typeAnnotation);
+
+  /// When deserializing we have already consumed the message type, so we don't
+  /// consume it again.
+  ReflectTypeRequest.deserialize(Deserializer deserializer)
+      : typeAnnotation = (deserializer..moveNext()).expectTypeAnnotation(),
+        super.deserialize(deserializer);
+
+  void serialize(Serializer serializer) {
+    serializer.addNum(MessageType.reflectTypeRequest.index);
+    typeAnnotation.serialize(serializer);
+    super.serialize(serializer);
+  }
+}
+
+/// TODO: Implement this
+class ClientTypeResolver implements TypeResolver {
+  @override
+  Future<StaticType> resolve(TypeAnnotation typeAnnotation) {
+    // TODO: implement resolve
+    throw new UnimplementedError();
+  }
+}
+
+/// TODO: Implement this
+class ClientClassIntrospector implements ClassIntrospector {
+  @override
+  Future<List<ConstructorDeclaration>> constructorsOf(ClassDeclaration clazz) {
+    // TODO: implement constructorsOf
+    throw new UnimplementedError();
+  }
+
+  @override
+  Future<List<FieldDeclaration>> fieldsOf(ClassDeclaration clazz) {
+    // TODO: implement fieldsOf
+    throw new UnimplementedError();
+  }
+
+  @override
+  Future<List<ClassDeclaration>> interfacesOf(ClassDeclaration clazz) {
+    // TODO: implement interfacesOf
+    throw new UnimplementedError();
+  }
+
+  @override
+  Future<List<MethodDeclaration>> methodsOf(ClassDeclaration clazz) {
+    // TODO: implement methodsOf
+    throw new UnimplementedError();
+  }
+
+  @override
+  Future<List<ClassDeclaration>> mixinsOf(ClassDeclaration clazz) {
+    // TODO: implement mixinsOf
+    throw new UnimplementedError();
+  }
+
+  @override
+  Future<ClassDeclaration?> superclassOf(ClassDeclaration clazz) {
+    // TODO: implement superclassOf
+    throw new UnimplementedError();
+  }
+}
+
+/// TODO: Implement this
+class ClientTypeDeclarationsResolver implements TypeDeclarationResolver {
+  @override
+  Future<TypeDeclaration> declarationOf(NamedStaticType annotation) {
+    // TODO: implement declarationOf
+    throw new UnimplementedError();
+  }
+}
+
+enum MessageType {
+  error,
+  executeDefinitionsPhaseRequest,
+  instantiateMacroRequest,
+  loadMacroRequest,
+  reflectTypeRequest,
+  macroClassIdentifier,
+  macroInstanceIdentifier,
+  macroExecutionResult,
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/response_impls.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/response_impls.dart
new file mode 100644
index 0000000..5155f01
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/response_impls.dart
@@ -0,0 +1,222 @@
+// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+
+import '../executor.dart';
+import '../api.dart';
+import 'serialization.dart';
+import 'serialization_extensions.dart';
+
+/// Implementation of [MacroClassIdentifier].
+class MacroClassIdentifierImpl implements MacroClassIdentifier {
+  final String id;
+
+  MacroClassIdentifierImpl(Uri library, String name) : id = '$library#$name';
+
+  MacroClassIdentifierImpl.deserialize(Deserializer deserializer)
+      : id = (deserializer..moveNext()).expectString();
+
+  void serialize(Serializer serializer) => serializer.addString(id);
+
+  operator ==(other) => other is MacroClassIdentifierImpl && id == other.id;
+
+  int get hashCode => id.hashCode;
+}
+
+/// Implementation of [MacroInstanceIdentifier].
+class MacroInstanceIdentifierImpl implements MacroInstanceIdentifier {
+  static int _next = 0;
+
+  final int id;
+
+  MacroInstanceIdentifierImpl() : id = _next++;
+
+  MacroInstanceIdentifierImpl.deserialize(Deserializer deserializer)
+      : id = (deserializer..moveNext()).expectNum();
+
+  void serialize(Serializer serializer) => serializer.addNum(id);
+
+  operator ==(other) => other is MacroInstanceIdentifierImpl && id == other.id;
+
+  int get hashCode => id;
+}
+
+/// Implementation of [MacroExecutionResult].
+class MacroExecutionResultImpl implements MacroExecutionResult {
+  @override
+  final List<DeclarationCode> augmentations;
+
+  @override
+  final List<DeclarationCode> imports;
+
+  MacroExecutionResultImpl({
+    List<DeclarationCode>? augmentations,
+    List<DeclarationCode>? imports,
+  })  : augmentations = augmentations ?? [],
+        imports = imports ?? [];
+
+  factory MacroExecutionResultImpl.deserialize(Deserializer deserializer) {
+    deserializer.moveNext();
+    deserializer.expectList();
+    List<DeclarationCode> augmentations = [
+      for (bool hasNext = deserializer.moveNext();
+          hasNext;
+          hasNext = deserializer.moveNext())
+        deserializer.expectCode()
+    ];
+    deserializer.moveNext();
+    deserializer.expectList();
+    List<DeclarationCode> imports = [
+      for (bool hasNext = deserializer.moveNext();
+          hasNext;
+          hasNext = deserializer.moveNext())
+        deserializer.expectCode()
+    ];
+
+    return new MacroExecutionResultImpl(
+      augmentations: augmentations,
+      imports: imports,
+    );
+  }
+
+  void serialize(Serializer serializer) {
+    serializer.startList();
+    for (DeclarationCode augmentation in augmentations) {
+      augmentation.serialize(serializer);
+    }
+    serializer.endList();
+    serializer.startList();
+    for (DeclarationCode import in imports) {
+      import.serialize(serializer);
+    }
+    serializer.endList();
+  }
+}
+
+/// Implementation of [FunctionDefinitionBuilder].
+class FunctionDefinitionBuilderImpl implements FunctionDefinitionBuilder {
+  final TypeResolver typeResolver;
+  final TypeDeclarationResolver typeDeclarationResolver;
+  final ClassIntrospector classIntrospector;
+
+  /// The declaration this is a builder for.
+  final FunctionDeclaration declaration;
+
+  /// The final result, will be built up over `augment` calls.
+  final MacroExecutionResultImpl result;
+
+  FunctionDefinitionBuilderImpl(this.declaration, this.typeResolver,
+      this.typeDeclarationResolver, this.classIntrospector)
+      : result = new MacroExecutionResultImpl();
+
+  FunctionDefinitionBuilderImpl.deserialize(Deserializer deserializer,
+      this.typeResolver, this.typeDeclarationResolver, this.classIntrospector)
+      : declaration =
+            (deserializer..moveNext()).expectDeclaration<FunctionDeclaration>(),
+        result = new MacroExecutionResultImpl.deserialize(deserializer);
+
+  void serialize(Serializer serializer) {
+    // Note that the `typeResolver`, `typeDeclarationResolver`, and
+    // `classIntrospector` are not serialized. These have custom implementations
+    // on the client/server side.
+    declaration.serialize(serializer);
+    result.serialize(serializer);
+  }
+
+  @override
+  void augment(FunctionBodyCode body) {
+    result.augmentations.add(new DeclarationCode.fromParts([
+      'augment ',
+      declaration.returnType.code,
+      ' ',
+      declaration.name,
+      if (declaration.typeParameters.isNotEmpty) ...[
+        '<',
+        for (TypeParameterDeclaration typeParam
+            in declaration.typeParameters) ...[
+          typeParam.name,
+          if (typeParam.bounds != null) ...['extends ', typeParam.bounds!.code],
+          if (typeParam != declaration.typeParameters.last) ', ',
+        ],
+        '>',
+      ],
+      '(',
+      for (ParameterDeclaration positionalRequired
+          in declaration.positionalParameters.where((p) => p.isRequired)) ...[
+        new ParameterCode.fromParts([
+          positionalRequired.type.code,
+          ' ',
+          positionalRequired.name,
+        ]),
+        ', '
+      ],
+      if (declaration.positionalParameters.any((p) => !p.isRequired)) ...[
+        '[',
+        for (ParameterDeclaration positionalOptional in declaration
+            .positionalParameters
+            .where((p) => !p.isRequired)) ...[
+          new ParameterCode.fromParts([
+            positionalOptional.type.code,
+            ' ',
+            positionalOptional.name,
+          ]),
+          ', ',
+        ],
+        ']',
+      ],
+      if (declaration.namedParameters.isNotEmpty) ...[
+        '{',
+        for (ParameterDeclaration named in declaration.namedParameters) ...[
+          new ParameterCode.fromParts([
+            if (named.isRequired) 'required ',
+            named.type.code,
+            ' ',
+            named.name,
+            if (named.defaultValue != null) ...[
+              ' = ',
+              named.defaultValue!,
+            ],
+          ]),
+          ', ',
+        ],
+        '}',
+      ],
+      ') ',
+      body,
+    ]));
+  }
+
+  @override
+  Future<List<ConstructorDeclaration>> constructorsOf(ClassDeclaration clazz) =>
+      classIntrospector.constructorsOf(clazz);
+
+  @override
+  Future<List<FieldDeclaration>> fieldsOf(ClassDeclaration clazz) =>
+      classIntrospector.fieldsOf(clazz);
+
+  @override
+  Future<List<ClassDeclaration>> interfacesOf(ClassDeclaration clazz) =>
+      classIntrospector.interfacesOf(clazz);
+
+  @override
+  Future<List<MethodDeclaration>> methodsOf(ClassDeclaration clazz) =>
+      classIntrospector.methodsOf(clazz);
+
+  @override
+  Future<List<ClassDeclaration>> mixinsOf(ClassDeclaration clazz) =>
+      classIntrospector.mixinsOf(clazz);
+
+  @override
+  Future<TypeDeclaration> declarationOf(NamedStaticType annotation) =>
+      typeDeclarationResolver.declarationOf(annotation);
+
+  @override
+  Future<ClassDeclaration?> superclassOf(ClassDeclaration clazz) =>
+      classIntrospector.superclassOf(clazz);
+
+  @override
+  Future<StaticType> resolve(TypeAnnotation typeAnnotation) =>
+      typeResolver.resolve(typeAnnotation);
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/serialization.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/serialization.dart
new file mode 100644
index 0000000..f5f9343
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/serialization.dart
@@ -0,0 +1,229 @@
+// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+
+/// All serialization must be done in a serialization Zone, which tells it
+/// whether we are the client or server.
+T withSerializationMode<T>(SerializationMode mode, T Function() fn) =>
+    runZoned(fn, zoneValues: {#serializationMode: mode});
+
+/// Serializable interface
+abstract class Serializable {
+  /// Serializes this object using [serializer].
+  void serialize(Serializer serializer);
+}
+
+/// A push based object serialization interface.
+abstract class Serializer {
+  /// Serializes a [String].
+  void addString(String value);
+
+  /// Serializes a nullable [String].
+  void addNullableString(String? value);
+
+  /// Serializes a [num].
+  void addNum(num value);
+
+  /// Serializes a nullable [num].
+  void addNullableNum(num? value);
+
+  /// Serializes a [bool].
+  void addBool(bool value);
+
+  /// Serializes a nullable [bool].
+  void addNullableBool(bool? value);
+
+  /// Serializes a `null` literal.
+  void addNull();
+
+  /// Used to signal the start of an arbitrary length list of items.
+  void startList();
+
+  /// Used to signal the end of an arbitrary length list of items.
+  void endList();
+}
+
+/// A pull based object deserialization interface.
+///
+/// You must call [moveNext] before reading any items, and in order to advance
+/// to the next item.
+abstract class Deserializer {
+  /// Checks if the current value is a null, returns `true` if so and `false`
+  /// otherwise.
+  bool checkNull();
+
+  /// Reads the current value as a non-nullable [String].
+  bool expectBool();
+
+  /// Reads the current value as a nullable [bool].
+  bool? expectNullableBool();
+
+  /// Reads the current value as a non-nullable [String].
+  T expectNum<T extends num>();
+
+  /// Reads the current value as a nullable [num].
+  num? expectNullableNum();
+
+  /// Reads the current value as a non-nullable [String].
+  String expectString();
+
+  /// Reads the current value as a nullable [String].
+  String? expectNullableString();
+
+  /// Asserts that the current item is the start of a list.
+  ///
+  /// An example for how to read from a list is as follows:
+  ///
+  /// var json = JsonReader.fromString(source);
+  /// I know it's a list of strings.
+  ///
+  /// ```
+  ///   var result = <String>[];
+  ///   deserializer.moveNext();
+  ///   deserializer.expectList();
+  ///   while (json.moveNext()) {
+  ///     result.add(json.expectString());
+  ///   }
+  ///   // Can now read later items, but need to call `moveNext` again to move
+  ///   // past the list.
+  ///   deserializer.moveNext();
+  ///   deserializer.expectBool();
+  /// ```
+  void expectList();
+
+  /// Moves to the next item, returns `false` if there are no more items to
+  /// read.
+  ///
+  /// If inside of a list, this returns `false` when the end of the list is
+  /// reached, and moves back to the parent, but does not advance it, so another
+  /// call to `moveNext` is needed. See example in the [expectList] docs.
+  bool moveNext();
+}
+
+class JsonSerializer implements Serializer {
+  /// The full result.
+  final _result = <Object?>[];
+
+  /// A path to the current list we are modifying.
+  late List<List<Object?>> _path = [_result];
+
+  /// Returns the result as an unmodifiable [Iterable].
+  ///
+  /// Asserts that all [List] entries have not been closed with [endList].
+  Iterable<Object?> get result {
+    assert(_path.length == 1);
+    return _result;
+  }
+
+  @override
+  void addBool(bool value) => _path.last.add(value);
+  @override
+  void addNullableBool(bool? value) => _path.last.add(value);
+
+  @override
+  void addNum(num value) => _path.last.add(value);
+  @override
+  void addNullableNum(num? value) => _path.last.add(value);
+
+  @override
+  void addString(String value) => _path.last.add(value);
+  @override
+  void addNullableString(String? value) => _path.last.add(value);
+
+  @override
+  void addNull() => _path.last.add(null);
+
+  @override
+  void startList() {
+    List<Object?> sublist = [];
+    _path.last.add(sublist);
+    _path.add(sublist);
+  }
+
+  @override
+  void endList() {
+    _path.removeLast();
+  }
+}
+
+class JsonDeserializer implements Deserializer {
+  /// The root source list to read from.
+  final Iterable<Object?> _source;
+
+  /// The path to the current iterator we are reading from.
+  late List<Iterator<Object?>> _path = [];
+
+  /// Whether we have received our first [moveNext] call.
+  bool _initialized = false;
+
+  /// Initialize this deserializer from `_source`.
+  JsonDeserializer(this._source);
+
+  @override
+  bool checkNull() => _expectValue<Object?>() == null;
+
+  @override
+  void expectList() => _path.add(_expectValue<Iterable<Object?>>().iterator);
+
+  @override
+  bool expectBool() => _expectValue();
+  @override
+  bool? expectNullableBool() => _expectValue();
+
+  @override
+  T expectNum<T extends num>() => _expectValue();
+  @override
+  num? expectNullableNum() => _expectValue();
+
+  @override
+  String expectString() => _expectValue();
+  @override
+  String? expectNullableString() => _expectValue();
+
+  /// Reads the current value and casts it to [T].
+  T _expectValue<T>() {
+    if (!_initialized) {
+      throw new StateError(
+          'You must call `moveNext()` before reading any values.');
+    }
+    return _path.last.current as T;
+  }
+
+  @override
+  bool moveNext() {
+    if (!_initialized) {
+      _path.add(_source.iterator);
+      _initialized = true;
+    }
+
+    // Move the current iterable, if its at the end of its items remove it from
+    // the current path and return false.
+    if (!_path.last.moveNext()) {
+      _path.removeLast();
+      return false;
+    }
+
+    return true;
+  }
+}
+
+/// Must be set using `withSerializationMode` before doing any serialization or
+/// deserialization.
+SerializationMode get serializationMode {
+  SerializationMode? mode =
+      Zone.current[#serializationMode] as SerializationMode?;
+  if (mode == null) {
+    throw new StateError('No SerializationMode set, you must do all '
+        'serialization inside a call to `withSerializationMode`.');
+  }
+  return mode;
+}
+
+/// Some objects are serialized differently on the client side versus the server
+/// side. This indicates the different modes.
+enum SerializationMode {
+  server,
+  client,
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/serialization_extensions.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/serialization_extensions.dart
new file mode 100644
index 0000000..01cb768
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/serialization_extensions.dart
@@ -0,0 +1,416 @@
+import 'package:_fe_analyzer_shared/src/macros/executor_shared/introspection_impls.dart';
+
+import 'serialization.dart';
+import '../api.dart';
+
+extension DeserializerExtensions on Deserializer {
+  TypeAnnotation expectTypeAnnotation() {
+    int id = expectNum();
+    switch (serializationMode) {
+      case SerializationMode.server:
+        return _typeAnnotationsById[id]!;
+      case SerializationMode.client:
+        TypeAnnotation typeAnnotation;
+        moveNext();
+        TypeAnnotationKind type = TypeAnnotationKind.values[expectNum()];
+        moveNext();
+        switch (type) {
+          case TypeAnnotationKind.namedType:
+            typeAnnotation = _expectNamedTypeAnnotation();
+            break;
+          case TypeAnnotationKind.functionType:
+            typeAnnotation = _expectFunctionTypeAnnotation();
+            break;
+        }
+        _typeAnnotationIds[typeAnnotation] = id;
+        return typeAnnotation;
+    }
+  }
+
+  NamedTypeAnnotation _expectNamedTypeAnnotation() {
+    bool isNullable = expectBool();
+    moveNext();
+    String name = expectString();
+    moveNext();
+    expectList();
+    List<TypeAnnotation> typeArguments = [
+      for (bool hasNext = moveNext(); hasNext; hasNext = moveNext())
+        expectTypeAnnotation(),
+    ];
+    return new NamedTypeAnnotationImpl(
+        isNullable: isNullable, name: name, typeArguments: typeArguments);
+  }
+
+  FunctionTypeAnnotation _expectFunctionTypeAnnotation() {
+    bool isNullable = expectBool();
+
+    moveNext();
+    TypeAnnotation returnType = expectTypeAnnotation();
+
+    moveNext();
+    expectList();
+    List<ParameterDeclaration> positionalParameters = [
+      for (bool hasNext = moveNext(); hasNext; hasNext = moveNext())
+        expectDeclaration(),
+    ];
+
+    moveNext();
+    expectList();
+    List<ParameterDeclaration> namedParameters = [
+      for (bool hasNext = moveNext(); hasNext; hasNext = moveNext())
+        expectDeclaration(),
+    ];
+
+    moveNext();
+    expectList();
+    List<TypeParameterDeclaration> typeParameters = [
+      for (bool hasNext = moveNext(); hasNext; hasNext = moveNext())
+        expectDeclaration(),
+    ];
+
+    return new FunctionTypeAnnotationImpl(
+        isNullable: isNullable,
+        returnType: returnType,
+        positionalParameters: positionalParameters,
+        namedParameters: namedParameters,
+        typeParameters: typeParameters);
+  }
+
+  T expectDeclaration<T extends Declaration>() {
+    DeclarationKind kind = DeclarationKind.values[expectNum()];
+    moveNext();
+    switch (kind) {
+      case DeclarationKind.parameter:
+        return _expectParameterDeclaration() as T;
+      case DeclarationKind.typeParameter:
+        return _expectTypeParameterDeclaration() as T;
+      case DeclarationKind.function:
+        return _expectFunctionDeclaration() as T;
+      default:
+        throw new UnimplementedError('Cant deserialize $kind yet');
+    }
+  }
+
+  ParameterDeclaration _expectParameterDeclaration() {
+    String name = expectString();
+    moveNext();
+    Code? defaultValue;
+    if (!checkNull()) {
+      defaultValue = expectCode();
+    }
+    bool isNamed = expectBool();
+    moveNext();
+    bool isRequired = expectBool();
+    moveNext();
+    TypeAnnotation type = expectTypeAnnotation();
+
+    return new ParameterDeclarationImpl(
+        defaultValue: defaultValue,
+        isNamed: isNamed,
+        isRequired: isRequired,
+        name: name,
+        type: type);
+  }
+
+  TypeParameterDeclaration _expectTypeParameterDeclaration() {
+    String name = expectString();
+    moveNext();
+    TypeAnnotation? bounds;
+    if (!checkNull()) {
+      bounds = expectTypeAnnotation();
+    }
+    return new TypeParameterDeclarationImpl(name: name, bounds: bounds);
+  }
+
+  FunctionDeclaration _expectFunctionDeclaration() {
+    String name = expectString();
+    moveNext();
+    bool isAbstract = expectBool();
+    moveNext();
+    bool isExternal = expectBool();
+    moveNext();
+    bool isGetter = expectBool();
+    moveNext();
+    bool isSetter = expectBool();
+
+    moveNext();
+    expectList();
+    List<ParameterDeclaration> namedParameters = [
+      for (bool hasNext = moveNext(); hasNext; hasNext = moveNext())
+        expectDeclaration()
+    ];
+
+    moveNext();
+    expectList();
+    List<ParameterDeclaration> positionalParameters = [
+      for (bool hasNext = moveNext(); hasNext; hasNext = moveNext())
+        expectDeclaration()
+    ];
+
+    moveNext();
+    TypeAnnotation returnType = expectTypeAnnotation();
+
+    moveNext();
+    expectList();
+    List<TypeParameterDeclaration> typeParameters = [
+      for (bool hasNext = moveNext(); hasNext; hasNext = moveNext())
+        expectDeclaration()
+    ];
+    return new FunctionDeclarationImpl(
+        name: name,
+        isAbstract: isAbstract,
+        isExternal: isExternal,
+        isGetter: isGetter,
+        isSetter: isSetter,
+        namedParameters: namedParameters,
+        positionalParameters: positionalParameters,
+        returnType: returnType,
+        typeParameters: typeParameters);
+  }
+
+  T expectCode<T extends Code>() {
+    CodeKind kind = CodeKind.values[expectNum()];
+    moveNext();
+    expectList();
+    List<Object> parts = [];
+    while (moveNext()) {
+      CodePartKind partKind = CodePartKind.values[expectNum()];
+      moveNext();
+      switch (partKind) {
+        case CodePartKind.code:
+          parts.add(expectCode());
+          break;
+        case CodePartKind.string:
+          parts.add(expectString());
+          break;
+        case CodePartKind.typeAnnotation:
+          parts.add(expectTypeAnnotation());
+          break;
+      }
+    }
+
+    switch (kind) {
+      case CodeKind.raw:
+        return new Code.fromParts(parts) as T;
+      case CodeKind.declaration:
+        return new DeclarationCode.fromParts(parts) as T;
+      case CodeKind.element:
+        return new ElementCode.fromParts(parts) as T;
+      case CodeKind.expression:
+        return new ExpressionCode.fromParts(parts) as T;
+      case CodeKind.functionBody:
+        return new FunctionBodyCode.fromParts(parts) as T;
+      case CodeKind.identifier:
+        return new IdentifierCode.fromParts(parts) as T;
+      case CodeKind.namedArgument:
+        return new NamedArgumentCode.fromParts(parts) as T;
+      case CodeKind.parameter:
+        return new ParameterCode.fromParts(parts) as T;
+      case CodeKind.statement:
+        return new StatementCode.fromParts(parts) as T;
+    }
+  }
+}
+
+/// On the server side we keep track of type annotations by their ID.
+final _typeAnnotationsById = <int, TypeAnnotation>{};
+
+/// On the client side we keep an expando of ids on [TypeAnnotation]s.
+final _typeAnnotationIds = new Expando<int>();
+
+/// Incrementing ids for [TypeAnnotationImpl]s
+int _nextTypeAnnotationId = 0;
+
+extension SerializeTypeAnnotation on TypeAnnotation {
+  void serialize(Serializer serializer) {
+    TypeAnnotation self = this;
+    if (self is NamedTypeAnnotationImpl) {
+      self.serialize(serializer);
+    } else if (self is FunctionTypeAnnotationImpl) {
+      self.serialize(serializer);
+    } else {
+      throw new UnsupportedError(
+          'Type ${this.runtimeType} is not supported for serialization.');
+    }
+  }
+}
+
+/// Does the parts of serialization for type annotations that is shared between
+/// implementations.
+///
+/// Returns `false` if we should continue serializing the rest of the object, or
+/// `true` if the object is fully serialized (just an ID).
+bool _doSharedTypeAnnotationSerialization(Serializer serializer,
+    TypeAnnotation typeAnnotation, TypeAnnotationKind kind) {
+  switch (serializationMode) {
+    case SerializationMode.client:
+      // Only send the ID from the client side, and assume we have one.
+      int id = _typeAnnotationIds[typeAnnotation]!;
+      serializer.addNum(id);
+      return true;
+    case SerializationMode.server:
+      // Server side we may create new ids for unseen annotations,
+      // and continue to serialize the rest of the annotation.
+      int id = _typeAnnotationIds[typeAnnotation] ?? _nextTypeAnnotationId++;
+      // TODO: We should clean these up at some point.
+      _typeAnnotationsById[id] = typeAnnotation;
+      serializer.addNum(id);
+      break;
+  }
+  serializer.addNum(kind.index);
+  serializer.addBool(typeAnnotation.isNullable);
+  return false;
+}
+
+extension SerializeNamedTypeAnnotation on NamedTypeAnnotation {
+  void serialize(Serializer serializer) {
+    if (_doSharedTypeAnnotationSerialization(
+        serializer, this, TypeAnnotationKind.namedType)) {
+      return;
+    }
+    serializer.addString(name);
+    serializer.startList();
+    for (TypeAnnotation typeArg in typeArguments) {
+      typeArg.serialize(serializer);
+    }
+    serializer.endList();
+  }
+}
+
+extension SerializeFunctionTypeAnnotation on FunctionTypeAnnotation {
+  void serialize(Serializer serializer) {
+    if (_doSharedTypeAnnotationSerialization(
+        serializer, this, TypeAnnotationKind.functionType)) {
+      return;
+    }
+
+    returnType.serialize(serializer);
+
+    serializer.startList();
+    for (ParameterDeclaration param in positionalParameters) {
+      param.serialize(serializer);
+    }
+    serializer.endList();
+
+    serializer.startList();
+    for (ParameterDeclaration param in namedParameters) {
+      param.serialize(serializer);
+    }
+    serializer.endList();
+
+    serializer.startList();
+    for (TypeParameterDeclaration typeParam in typeParameters) {
+      typeParam.serialize(serializer);
+    }
+    serializer.endList();
+  }
+}
+
+/// Does the shared parts of [Declaration] serialization.
+void _serializeDeclaration(Serializer serializer, Declaration declaration) {
+  serializer.addNum(declaration.kind.index);
+  serializer.addString(declaration.name);
+}
+
+/// Checks the type and deserializes it appropriately.
+extension SerializeDeclaration on Declaration {
+  void serialize(Serializer serializer) {
+    switch (kind) {
+      case DeclarationKind.parameter:
+        (this as ParameterDeclaration).serialize(serializer);
+        break;
+      case DeclarationKind.typeParameter:
+        (this as TypeParameterDeclaration).serialize(serializer);
+        break;
+      case DeclarationKind.function:
+        (this as FunctionDeclaration).serialize(serializer);
+        break;
+      default:
+        throw new UnimplementedError('Cant serialize $kind yet');
+    }
+  }
+}
+
+extension SerializeParameterDeclaration on ParameterDeclaration {
+  void serialize(Serializer serializer) {
+    _serializeDeclaration(serializer, this);
+    if (defaultValue == null) {
+      serializer.addNull();
+    } else {
+      defaultValue!.serialize(serializer);
+    }
+    serializer.addBool(isNamed);
+    serializer.addBool(isRequired);
+    type.serialize(serializer);
+  }
+}
+
+extension SerializeTypeParameterDeclaration on TypeParameterDeclaration {
+  void serialize(Serializer serializer) {
+    _serializeDeclaration(serializer, this);
+    TypeAnnotation? bounds = this.bounds;
+    if (bounds == null) {
+      serializer.addNull();
+    } else {
+      bounds.serialize(serializer);
+    }
+  }
+}
+
+extension SerializeFunctionDeclaration on FunctionDeclaration {
+  void serialize(Serializer serializer) {
+    _serializeDeclaration(serializer, this);
+    serializer
+      ..addBool(isAbstract)
+      ..addBool(isExternal)
+      ..addBool(isGetter)
+      ..addBool(isSetter)
+      ..startList();
+    for (ParameterDeclaration named in namedParameters) {
+      named.serialize(serializer);
+    }
+    serializer
+      ..endList()
+      ..startList();
+    for (ParameterDeclaration positional in positionalParameters) {
+      positional.serialize(serializer);
+    }
+    serializer.endList();
+    returnType.serialize(serializer);
+    serializer.startList();
+    for (TypeParameterDeclaration param in typeParameters) {
+      param.serialize(serializer);
+    }
+    serializer.endList();
+  }
+}
+
+extension SerializeCode on Code {
+  void serialize(Serializer serializer) {
+    serializer
+      ..addNum(kind.index)
+      ..startList();
+    for (Object part in parts) {
+      if (part is String) {
+        serializer
+          ..addNum(CodePartKind.string.index)
+          ..addString(part);
+      } else if (part is Code) {
+        serializer.addNum(CodePartKind.code.index);
+        part.serialize(serializer);
+      } else if (part is TypeAnnotation) {
+        serializer.addNum(CodePartKind.typeAnnotation.index);
+        part.serialize(serializer);
+      } else {
+        throw new StateError('Unrecognized code part $part');
+      }
+    }
+    serializer.endList();
+  }
+}
+
+enum CodePartKind {
+  string,
+  code,
+  typeAnnotation,
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_executor.dart b/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_executor.dart
index 48b0229..136a6d5 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_executor.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_executor.dart
@@ -7,7 +7,7 @@
 import 'dart:mirrors';
 
 import 'isolate_mirrors_impl.dart';
-import 'protocol.dart';
+import '../executor_shared/protocol.dart';
 import '../executor.dart';
 import '../api.dart';
 
@@ -29,10 +29,10 @@
   final SendPort _sendPort;
 
   /// The stream of responses from the [_macroIsolate].
-  final Stream<GenericResponse> _responseStream;
+  final Stream<Response> _responseStream;
 
   /// A map of response completers by request id.
-  final _responseCompleters = <int, Completer<GenericResponse>>{};
+  final _responseCompleters = <int, Completer<Response>>{};
 
   /// A function that should be invoked when shutting down this executor
   /// to perform any necessary cleanup.
@@ -41,7 +41,7 @@
   _IsolateMirrorMacroExecutor._(
       this._macroIsolate, this._sendPort, this._responseStream, this._onClose) {
     _responseStream.listen((event) {
-      Completer<GenericResponse>? completer =
+      Completer<Response>? completer =
           _responseCompleters.remove(event.requestId);
       if (completer == null) {
         throw new StateError(
@@ -57,13 +57,13 @@
   static Future<MacroExecutor> start() async {
     ReceivePort receivePort = new ReceivePort();
     Completer<SendPort> sendPortCompleter = new Completer<SendPort>();
-    StreamController<GenericResponse> responseStreamController =
-        new StreamController<GenericResponse>(sync: true);
+    StreamController<Response> responseStreamController =
+        new StreamController<Response>(sync: true);
     receivePort.listen((message) {
       if (!sendPortCompleter.isCompleted) {
         sendPortCompleter.complete(message as SendPort);
       } else {
-        responseStreamController.add(message as GenericResponse);
+        responseStreamController.add(message as Response);
       }
     }).onDone(responseStreamController.close);
     Isolate macroIsolate = await Isolate.spawn(spawn, receivePort.sendPort);
@@ -124,18 +124,24 @@
           new InstantiateMacroRequest(macroClass, constructor, arguments));
 
   @override
-  Future<MacroClassIdentifier> loadMacro(Uri library, String name) =>
-      _sendRequest(new LoadMacroRequest(library, name));
+  Future<MacroClassIdentifier> loadMacro(Uri library, String name,
+      {Uri? precompiledKernelUri}) {
+    if (precompiledKernelUri != null) {
+      // TODO: Implement support?
+      throw new UnsupportedError(
+          'The IsolateMirrorsExecutor does not support precompiled dill files');
+    }
+    return _sendRequest(new LoadMacroRequest(library, name));
+  }
 
   /// Sends a request and returns the response, casting it to the expected
   /// type.
   Future<T> _sendRequest<T>(Request request) async {
     _sendPort.send(request);
-    Completer<GenericResponse<T>> completer =
-        new Completer<GenericResponse<T>>();
+    Completer<Response> completer = new Completer<Response>();
     _responseCompleters[request.id] = completer;
-    GenericResponse<T> response = await completer.future;
-    T? result = response.response;
+    Response response = await completer.future;
+    T? result = response.response as T?;
     if (result != null) return result;
     throw response.error!;
   }
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_impl.dart b/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_impl.dart
index 3cf24a5..e6848f8 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_impl.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_impl.dart
@@ -6,8 +6,8 @@
 import 'dart:isolate';
 import 'dart:mirrors';
 
-import 'protocol.dart';
-import '../executor.dart';
+import '../executor_shared/response_impls.dart';
+import '../executor_shared/protocol.dart';
 import '../api.dart';
 
 /// Spawns a new isolate for loading and executing macros.
@@ -15,33 +15,28 @@
   ReceivePort receivePort = new ReceivePort();
   sendPort.send(receivePort.sendPort);
   receivePort.listen((message) async {
+    Response response;
     if (message is LoadMacroRequest) {
-      GenericResponse<MacroClassIdentifier> response =
-          await _loadMacro(message);
-      sendPort.send(response);
+      response = await _loadMacro(message);
     } else if (message is InstantiateMacroRequest) {
-      GenericResponse<MacroInstanceIdentifier> response =
-          await _instantiateMacro(message);
-      sendPort.send(response);
+      response = await _instantiateMacro(message);
     } else if (message is ExecuteDefinitionsPhaseRequest) {
-      GenericResponse<MacroExecutionResult> response =
-          await _executeDefinitionsPhase(message);
-      sendPort.send(response);
+      response = await _executeDefinitionsPhase(message);
     } else {
       throw new StateError('Unrecognized event type $message');
     }
+    sendPort.send(response);
   });
 }
 
 /// Maps macro identifiers to class mirrors.
-final _macroClasses = <_MacroClassIdentifier, ClassMirror>{};
+final _macroClasses = <MacroClassIdentifierImpl, ClassMirror>{};
 
 /// Handles [LoadMacroRequest]s.
-Future<GenericResponse<MacroClassIdentifier>> _loadMacro(
-    LoadMacroRequest request) async {
+Future<Response> _loadMacro(LoadMacroRequest request) async {
   try {
-    _MacroClassIdentifier identifier =
-        new _MacroClassIdentifier(request.library, request.name);
+    MacroClassIdentifierImpl identifier =
+        new MacroClassIdentifierImpl(request.library, request.name);
     if (_macroClasses.containsKey(identifier)) {
       throw new UnsupportedError(
           'Reloading macros is not supported by this implementation');
@@ -51,18 +46,17 @@
     ClassMirror macroClass =
         libMirror.declarations[new Symbol(request.name)] as ClassMirror;
     _macroClasses[identifier] = macroClass;
-    return new GenericResponse(response: identifier, requestId: request.id);
+    return new Response(response: identifier, requestId: request.id);
   } catch (e) {
-    return new GenericResponse(error: e, requestId: request.id);
+    return new Response(error: e, requestId: request.id);
   }
 }
 
 /// Maps macro instance identifiers to instances.
-final _macroInstances = <_MacroInstanceIdentifier, Macro>{};
+final _macroInstances = <MacroInstanceIdentifierImpl, Macro>{};
 
 /// Handles [InstantiateMacroRequest]s.
-Future<GenericResponse<MacroInstanceIdentifier>> _instantiateMacro(
-    InstantiateMacroRequest request) async {
+Future<Response> _instantiateMacro(InstantiateMacroRequest request) async {
   try {
     ClassMirror? clazz = _macroClasses[request.macroClass];
     if (clazz == null) {
@@ -73,16 +67,15 @@
       for (MapEntry<String, Object?> entry in request.arguments.named.entries)
         new Symbol(entry.key): entry.value,
     }).reflectee as Macro;
-    _MacroInstanceIdentifier identifier = new _MacroInstanceIdentifier();
+    MacroInstanceIdentifierImpl identifier = new MacroInstanceIdentifierImpl();
     _macroInstances[identifier] = instance;
-    return new GenericResponse<MacroInstanceIdentifier>(
-        response: identifier, requestId: request.id);
+    return new Response(response: identifier, requestId: request.id);
   } catch (e) {
-    return new GenericResponse(error: e, requestId: request.id);
+    return new Response(error: e, requestId: request.id);
   }
 }
 
-Future<GenericResponse<MacroExecutionResult>> _executeDefinitionsPhase(
+Future<Response> _executeDefinitionsPhase(
     ExecuteDefinitionsPhaseRequest request) async {
   try {
     Macro? instance = _macroInstances[request.macro];
@@ -93,163 +86,18 @@
     Declaration declaration = request.declaration;
     if (instance is FunctionDefinitionMacro &&
         declaration is FunctionDeclaration) {
-      _FunctionDefinitionBuilder builder = new _FunctionDefinitionBuilder(
+      FunctionDefinitionBuilderImpl builder = new FunctionDefinitionBuilderImpl(
           declaration,
           request.typeResolver,
           request.typeDeclarationResolver,
           request.classIntrospector);
       await instance.buildDefinitionForFunction(declaration, builder);
-      return new GenericResponse(
-          response: builder.result, requestId: request.id);
+      return new Response(response: builder.result, requestId: request.id);
     } else {
       throw new UnsupportedError(
           ('Only FunctionDefinitionMacros are supported currently'));
     }
   } catch (e) {
-    return new GenericResponse(error: e, requestId: request.id);
+    return new Response(error: e, requestId: request.id);
   }
 }
-
-/// Our implementation of [MacroClassIdentifier].
-class _MacroClassIdentifier implements MacroClassIdentifier {
-  final String id;
-
-  _MacroClassIdentifier(Uri library, String name) : id = '$library#$name';
-
-  operator ==(other) => other is _MacroClassIdentifier && id == other.id;
-
-  int get hashCode => id.hashCode;
-}
-
-/// Our implementation of [MacroInstanceIdentifier].
-class _MacroInstanceIdentifier implements MacroInstanceIdentifier {
-  static int _next = 0;
-
-  final int id;
-
-  _MacroInstanceIdentifier() : id = _next++;
-
-  operator ==(other) => other is _MacroInstanceIdentifier && id == other.id;
-
-  int get hashCode => id;
-}
-
-/// Our implementation of [MacroExecutionResult].
-class _MacroExecutionResult implements MacroExecutionResult {
-  @override
-  final List<DeclarationCode> augmentations = <DeclarationCode>[];
-
-  @override
-  final List<DeclarationCode> imports = <DeclarationCode>[];
-}
-
-/// Custom implementation of [FunctionDefinitionBuilder].
-class _FunctionDefinitionBuilder implements FunctionDefinitionBuilder {
-  final TypeResolver typeResolver;
-  final TypeDeclarationResolver typeDeclarationResolver;
-  final ClassIntrospector classIntrospector;
-
-  /// The declaration this is a builder for.
-  final FunctionDeclaration declaration;
-
-  /// The final result, will be built up over `augment` calls.
-  final _MacroExecutionResult result = new _MacroExecutionResult();
-
-  _FunctionDefinitionBuilder(this.declaration, this.typeResolver,
-      this.typeDeclarationResolver, this.classIntrospector);
-
-  @override
-  void augment(FunctionBodyCode body) {
-    result.augmentations.add(new DeclarationCode.fromParts([
-      'augment ',
-      declaration.returnType.code,
-      ' ',
-      declaration.name,
-      if (declaration.typeParameters.isNotEmpty) ...[
-        '<',
-        for (TypeParameterDeclaration typeParam
-            in declaration.typeParameters) ...[
-          typeParam.name,
-          if (typeParam.bounds != null) ...['extends ', typeParam.bounds!.code],
-          if (typeParam != declaration.typeParameters.last) ', ',
-        ],
-        '>',
-      ],
-      '(',
-      for (ParameterDeclaration positionalRequired
-          in declaration.positionalParameters.where((p) => p.isRequired)) ...[
-        new ParameterCode.fromParts([
-          positionalRequired.type.code,
-          ' ',
-          positionalRequired.name,
-        ]),
-        ', '
-      ],
-      if (declaration.positionalParameters.any((p) => !p.isRequired)) ...[
-        '[',
-        for (ParameterDeclaration positionalOptional in declaration
-            .positionalParameters
-            .where((p) => !p.isRequired)) ...[
-          new ParameterCode.fromParts([
-            positionalOptional.type.code,
-            ' ',
-            positionalOptional.name,
-          ]),
-          ', ',
-        ],
-        ']',
-      ],
-      if (declaration.namedParameters.isNotEmpty) ...[
-        '{',
-        for (ParameterDeclaration named in declaration.namedParameters) ...[
-          new ParameterCode.fromParts([
-            if (named.isRequired) 'required ',
-            named.type.code,
-            ' ',
-            named.name,
-            if (named.defaultValue != null) ...[
-              ' = ',
-              named.defaultValue!,
-            ],
-          ]),
-          ', ',
-        ],
-        '}',
-      ],
-      ') ',
-      body,
-    ]));
-  }
-
-  @override
-  Future<List<ConstructorDeclaration>> constructorsOf(ClassDeclaration clazz) =>
-      classIntrospector.constructorsOf(clazz);
-
-  @override
-  Future<List<FieldDeclaration>> fieldsOf(ClassDeclaration clazz) =>
-      classIntrospector.fieldsOf(clazz);
-
-  @override
-  Future<List<ClassDeclaration>> interfacesOf(ClassDeclaration clazz) =>
-      classIntrospector.interfacesOf(clazz);
-
-  @override
-  Future<List<MethodDeclaration>> methodsOf(ClassDeclaration clazz) =>
-      classIntrospector.methodsOf(clazz);
-
-  @override
-  Future<List<ClassDeclaration>> mixinsOf(ClassDeclaration clazz) =>
-      classIntrospector.mixinsOf(clazz);
-
-  @override
-  Future<TypeDeclaration> declarationOf(NamedStaticType annotation) =>
-      typeDeclarationResolver.declarationOf(annotation);
-
-  @override
-  Future<ClassDeclaration?> superclassOf(ClassDeclaration clazz) =>
-      classIntrospector.superclassOf(clazz);
-
-  @override
-  Future<StaticType> resolve(TypeAnnotation typeAnnotation) =>
-      typeResolver.resolve(typeAnnotation);
-}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/protocol.dart b/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/protocol.dart
deleted file mode 100644
index 96a2724..0000000
--- a/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/protocol.dart
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-/// Defines the objects used for communication between the macro executor and
-/// the isolate doing the work of macro loading and execution.
-library protocol;
-
-import '../executor.dart';
-import '../api.dart';
-
-/// Base class all requests extend, provides a unique id for each request.
-class Request {
-  final int id;
-
-  Request() : id = _next++;
-
-  static int _next = 0;
-}
-
-/// A generic response object that is either an instance of [T] or an error.
-class GenericResponse<T> {
-  final T? response;
-  final Object? error;
-  final int requestId;
-
-  GenericResponse({this.response, this.error, required this.requestId})
-      : assert(response != null || error != null),
-        assert(response == null || error == null);
-}
-
-/// A request to load a macro in this isolate.
-class LoadMacroRequest extends Request {
-  final Uri library;
-  final String name;
-
-  LoadMacroRequest(this.library, this.name);
-}
-
-/// A request to instantiate a macro instance.
-class InstantiateMacroRequest extends Request {
-  final MacroClassIdentifier macroClass;
-  final String constructorName;
-  final Arguments arguments;
-
-  InstantiateMacroRequest(
-      this.macroClass, this.constructorName, this.arguments);
-}
-
-/// A request to execute a macro on a particular declaration in the definition
-/// phase.
-class ExecuteDefinitionsPhaseRequest extends Request {
-  final MacroInstanceIdentifier macro;
-  final Declaration declaration;
-  final TypeResolver typeResolver;
-  final ClassIntrospector classIntrospector;
-  final TypeDeclarationResolver typeDeclarationResolver;
-
-  ExecuteDefinitionsPhaseRequest(this.macro, this.declaration,
-      this.typeResolver, this.classIntrospector, this.typeDeclarationResolver);
-}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/isolated_executor/isolated_executor.dart b/pkg/_fe_analyzer_shared/lib/src/macros/isolated_executor/isolated_executor.dart
new file mode 100644
index 0000000..b33dd94
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/isolated_executor/isolated_executor.dart
@@ -0,0 +1,227 @@
+// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:isolate';
+
+import '../api.dart';
+import '../executor_shared/protocol.dart';
+import '../executor_shared/serialization.dart';
+import '../executor_shared/response_impls.dart';
+import '../executor.dart';
+
+/// Returns an instance of [_IsolatedMacroExecutor].
+///
+/// This is the only public api exposed by this library.
+Future<MacroExecutor> start() async => new _IsolatedMacroExecutor();
+
+/// A [MacroExecutor] implementation which spawns a separate isolate for each
+/// macro that is loaded. Each of these is wrapped in its own
+/// [_SingleIsolatedMacroExecutor] which requests are delegated to.
+///
+/// This implementation requires precompiled kernel files when loading macros,
+/// (you must pass a `precompiledKernelUri` to [loadMacro]).
+///
+/// Spawned isolates are not ran in the same isolate group, so objects are
+/// serialized between isolates.
+class _IsolatedMacroExecutor implements MacroExecutor {
+  /// Individual executors indexed by [MacroClassIdentifier] or
+  /// [MacroInstanceIdentifier].
+  final _executors = <Object, _SingleIsolatedMacroExecutor>{};
+
+  @override
+  Future<String> buildAugmentationLibrary(
+      Iterable<MacroExecutionResult> macroResults) {
+    // TODO: implement buildAugmentationLibrary
+    throw new UnimplementedError();
+  }
+
+  @override
+  void close() {
+    for (_SingleIsolatedMacroExecutor executor in _executors.values) {
+      executor.close();
+    }
+  }
+
+  @override
+  Future<MacroExecutionResult> executeDeclarationsPhase(
+          MacroInstanceIdentifier macro,
+          Declaration declaration,
+          TypeResolver typeResolver,
+          ClassIntrospector classIntrospector) =>
+      _executors[macro]!.executeDeclarationsPhase(
+          macro, declaration, typeResolver, classIntrospector);
+
+  @override
+  Future<MacroExecutionResult> executeDefinitionsPhase(
+          MacroInstanceIdentifier macro,
+          Declaration declaration,
+          TypeResolver typeResolver,
+          ClassIntrospector classIntrospector,
+          TypeDeclarationResolver typeDeclarationResolver) =>
+      _executors[macro]!.executeDefinitionsPhase(macro, declaration,
+          typeResolver, classIntrospector, typeDeclarationResolver);
+
+  @override
+  Future<MacroExecutionResult> executeTypesPhase(
+          MacroInstanceIdentifier macro, Declaration declaration) =>
+      _executors[macro]!.executeTypesPhase(macro, declaration);
+
+  @override
+  Future<MacroInstanceIdentifier> instantiateMacro(
+      MacroClassIdentifier macroClass,
+      String constructor,
+      Arguments arguments) async {
+    _SingleIsolatedMacroExecutor executor = _executors[macroClass]!;
+    MacroInstanceIdentifier instance =
+        await executor.instantiateMacro(macroClass, constructor, arguments);
+    _executors[instance] = executor;
+    return instance;
+  }
+
+  @override
+  Future<MacroClassIdentifier> loadMacro(Uri library, String name,
+      {Uri? precompiledKernelUri}) async {
+    if (precompiledKernelUri == null) {
+      throw new UnsupportedError(
+          'This environment requires a non-null `precompiledKernelUri` to be '
+          'passed when loading macros.');
+    }
+    MacroClassIdentifier identifier =
+        new MacroClassIdentifierImpl(library, name);
+    _executors.remove(identifier)?.close();
+
+    _SingleIsolatedMacroExecutor executor =
+        await _SingleIsolatedMacroExecutor.start(
+            library, name, precompiledKernelUri);
+    _executors[identifier] = executor;
+    return identifier;
+  }
+}
+
+class _SingleIsolatedMacroExecutor extends MacroExecutor {
+  /// The stream on which we receive responses.
+  final Stream<Response> responseStream;
+
+  /// The send port where we should send requests.
+  final SendPort sendPort;
+
+  /// A function that should be invoked when shutting down this executor
+  /// to perform any necessary cleanup.
+  final void Function() onClose;
+
+  /// A map of response completers by request id.
+  final responseCompleters = <int, Completer<Response>>{};
+
+  _SingleIsolatedMacroExecutor(
+      {required this.onClose,
+      required this.responseStream,
+      required this.sendPort}) {
+    responseStream.listen((event) {
+      Completer<Response>? completer =
+          responseCompleters.remove(event.requestId);
+      if (completer == null) {
+        throw new StateError(
+            'Got a response for an unrecognized request id ${event.requestId}');
+      }
+      completer.complete(event);
+    });
+  }
+
+  static Future<_SingleIsolatedMacroExecutor> start(
+      Uri library, String name, Uri precompiledKernelUri) async {
+    ReceivePort receivePort = new ReceivePort();
+    Isolate isolate =
+        await Isolate.spawnUri(precompiledKernelUri, [], receivePort.sendPort);
+    Completer<SendPort> sendPortCompleter = new Completer();
+    StreamController<Response> responseStreamController =
+        new StreamController(sync: true);
+    receivePort.listen((message) {
+      if (!sendPortCompleter.isCompleted) {
+        sendPortCompleter.complete(message as SendPort);
+      } else {
+        withSerializationMode(SerializationMode.server, () {
+          JsonDeserializer deserializer =
+              new JsonDeserializer(message as List<Object?>);
+          SerializableResponse response =
+              new SerializableResponse.deserialize(deserializer);
+          responseStreamController.add(response);
+        });
+      }
+    }).onDone(responseStreamController.close);
+
+    return new _SingleIsolatedMacroExecutor(
+        onClose: () {
+          receivePort.close();
+          isolate.kill();
+        },
+        responseStream: responseStreamController.stream,
+        sendPort: await sendPortCompleter.future);
+  }
+
+  @override
+  void close() => onClose();
+
+  /// These calls are handled by the higher level executor.
+  @override
+  Future<String> buildAugmentationLibrary(
+          Iterable<MacroExecutionResult> macroResults) =>
+      throw new StateError('Unreachable');
+
+  @override
+  Future<MacroExecutionResult> executeDeclarationsPhase(
+      MacroInstanceIdentifier macro,
+      Declaration declaration,
+      TypeResolver typeResolver,
+      ClassIntrospector classIntrospector) {
+    // TODO: implement executeDeclarationsPhase
+    throw new UnimplementedError();
+  }
+
+  @override
+  Future<MacroExecutionResult> executeDefinitionsPhase(
+          MacroInstanceIdentifier macro,
+          Declaration declaration,
+          TypeResolver typeResolver,
+          ClassIntrospector classIntrospector,
+          TypeDeclarationResolver typeDeclarationResolver) =>
+      _sendRequest(new ExecuteDefinitionsPhaseRequest(macro, declaration,
+          typeResolver, classIntrospector, typeDeclarationResolver));
+
+  @override
+  Future<MacroExecutionResult> executeTypesPhase(
+      MacroInstanceIdentifier macro, Declaration declaration) {
+    // TODO: implement executeTypesPhase
+    throw new UnimplementedError();
+  }
+
+  @override
+  Future<MacroInstanceIdentifier> instantiateMacro(
+          MacroClassIdentifier macroClass,
+          String constructor,
+          Arguments arguments) =>
+      _sendRequest(
+          new InstantiateMacroRequest(macroClass, constructor, arguments));
+
+  /// These calls are handled by the higher level executor.
+  @override
+  Future<MacroClassIdentifier> loadMacro(Uri library, String name,
+          {Uri? precompiledKernelUri}) =>
+      throw new StateError('Unreachable');
+
+  /// Sends a [request] and handles the response, casting it to the expected
+  /// type or throwing the error provided.
+  Future<T> _sendRequest<T>(Request request) =>
+      withSerializationMode(SerializationMode.server, () async {
+        JsonSerializer serializer = new JsonSerializer();
+        request.serialize(serializer);
+        sendPort.send(serializer.result);
+        Completer<Response> completer = new Completer<Response>();
+        responseCompleters[request.id] = completer;
+        Response response = await completer.future;
+        T? result = response.response as T?;
+        if (result != null) return result;
+        throw response.error!;
+      });
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart b/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
index 204bd51..aa65f2b 100644
--- a/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
@@ -2779,12 +2779,12 @@
     problemMessage: r"""An enum declaration can't be empty.""");
 
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const Code<Null> codeEnumDeclaresFactory = messageEnumDeclaresFactory;
+const Code<Null> codeEnumDeclaresConstFactory = messageEnumDeclaresConstFactory;
 
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const MessageCode messageEnumDeclaresFactory = const MessageCode(
-    "EnumDeclaresFactory",
-    problemMessage: r"""Enums can't declare factory constructors.""",
+const MessageCode messageEnumDeclaresConstFactory = const MessageCode(
+    "EnumDeclaresConstFactory",
+    problemMessage: r"""Enums can't declare const factory constructors.""",
     correctionMessage:
         r"""Try removing the factory constructor declaration.""");
 
diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart b/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart
index 43e8331..a441a40 100644
--- a/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart
@@ -4375,8 +4375,6 @@
       case DeclarationKind.TopLevel:
         throw "Internal error: TopLevel factory.";
       case DeclarationKind.Enum:
-        reportRecoverableError(
-            factoryKeyword, codes.messageEnumDeclaresFactory);
         listener.endEnumFactoryMethod(beforeStart.next!, factoryKeyword, token);
         break;
     }
diff --git a/pkg/_fe_analyzer_shared/test/macros/executor_shared/serialization_test.dart b/pkg/_fe_analyzer_shared/test/macros/executor_shared/serialization_test.dart
new file mode 100644
index 0000000..c069423
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/macros/executor_shared/serialization_test.dart
@@ -0,0 +1,78 @@
+// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:_fe_analyzer_shared/src/macros/executor_shared/serialization.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('json serializer', () {
+    test('can serialize and deserialize data', () {
+      var serializer = JsonSerializer();
+      serializer
+        ..addNum(1)
+        ..addNullableNum(null)
+        ..addString('hello')
+        ..addNullableString(null)
+        ..startList()
+        ..addBool(true)
+        ..startList()
+        ..addNull()
+        ..endList()
+        ..addNullableBool(null)
+        ..endList()
+        ..addNum(1.0)
+        ..startList()
+        ..endList();
+      expect(
+          serializer.result,
+          equals([
+            1,
+            null,
+            'hello',
+            null,
+            [
+              true,
+              [null],
+              null
+            ],
+            1.0,
+            [],
+          ]));
+      var deserializer = JsonDeserializer(serializer.result);
+      expect(deserializer.moveNext(), true);
+      expect(deserializer.expectNum(), 1);
+      expect(deserializer.moveNext(), true);
+      expect(deserializer.expectNullableNum(), null);
+      expect(deserializer.moveNext(), true);
+      expect(deserializer.expectString(), 'hello');
+      expect(deserializer.moveNext(), true);
+      expect(deserializer.expectNullableString(), null);
+      expect(deserializer.moveNext(), true);
+
+      deserializer.expectList();
+      expect(deserializer.moveNext(), true);
+      expect(deserializer.expectBool(), true);
+      expect(deserializer.moveNext(), true);
+
+      deserializer.expectList();
+      expect(deserializer.moveNext(), true);
+      expect(deserializer.checkNull(), true);
+      expect(deserializer.moveNext(), false);
+
+      expect(deserializer.moveNext(), true);
+      expect(deserializer.expectNullableBool(), null);
+      expect(deserializer.moveNext(), false);
+
+      // Have to move the parent again to advance it past the list entry.
+      expect(deserializer.moveNext(), true);
+      expect(deserializer.expectNum(), 1.0);
+      expect(deserializer.moveNext(), true);
+
+      deserializer.expectList();
+      expect(deserializer.moveNext(), false);
+
+      expect(deserializer.moveNext(), false);
+    });
+  });
+}
diff --git a/pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/isolate_mirror_executor_test.dart b/pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/isolate_mirror_executor_test.dart
index ab7b057..7056208 100644
--- a/pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/isolate_mirror_executor_test.dart
+++ b/pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/isolate_mirror_executor_test.dart
@@ -6,6 +6,7 @@
 
 import 'package:_fe_analyzer_shared/src/macros/api.dart';
 import 'package:_fe_analyzer_shared/src/macros/executor.dart';
+import 'package:_fe_analyzer_shared/src/macros/executor_shared/introspection_impls.dart';
 import 'package:_fe_analyzer_shared/src/macros/isolate_mirrors_executor/isolate_mirrors_executor.dart'
     as mirrorExecutor;
 
@@ -26,7 +27,7 @@
   test('can load macros and create instances', () async {
     var clazzId = await executor.loadMacro(
         // Tests run from the root of the repo.
-        File('pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/simple_macro.dart')
+        File('pkg/_fe_analyzer_shared/test/macros/simple_macro.dart')
             .absolute
             .uri,
         'SimpleMacro');
@@ -49,7 +50,7 @@
 
     var definitionResult = await executor.executeDefinitionsPhase(
         instanceId,
-        _FunctionDeclaration(
+        FunctionDeclarationImpl(
           isAbstract: false,
           isExternal: false,
           isGetter: false,
@@ -57,8 +58,8 @@
           name: 'foo',
           namedParameters: [],
           positionalParameters: [],
-          returnType:
-              _TypeAnnotation(Code.fromString('String'), isNullable: false),
+          returnType: NamedTypeAnnotationImpl(
+              name: 'String', isNullable: false, typeArguments: const []),
           typeParameters: [],
         ),
         _FakeTypeResolver(),
@@ -82,63 +83,14 @@
     with Fake
     implements TypeDeclarationResolver {}
 
-class _FunctionDeclaration implements FunctionDeclaration {
-  @override
-  final bool isAbstract;
-
-  @override
-  final bool isExternal;
-
-  @override
-  final bool isGetter;
-
-  @override
-  final bool isSetter;
-
-  @override
-  final String name;
-
-  @override
-  final Iterable<ParameterDeclaration> namedParameters;
-
-  @override
-  final Iterable<ParameterDeclaration> positionalParameters;
-
-  @override
-  final TypeAnnotation returnType;
-
-  @override
-  final Iterable<TypeParameterDeclaration> typeParameters;
-
-  _FunctionDeclaration({
-    required this.isAbstract,
-    required this.isExternal,
-    required this.isGetter,
-    required this.isSetter,
-    required this.name,
-    required this.namedParameters,
-    required this.positionalParameters,
-    required this.returnType,
-    required this.typeParameters,
-  });
-}
-
-class _TypeAnnotation implements TypeAnnotation {
-  @override
-  final Code code;
-
-  @override
-  final bool isNullable;
-
-  _TypeAnnotation(this.code, {required this.isNullable});
-}
-
 extension _ on Code {
   StringBuffer debugString([StringBuffer? buffer]) {
     buffer ??= StringBuffer();
     for (var part in parts) {
       if (part is Code) {
         part.debugString(buffer);
+      } else if (part is TypeAnnotation) {
+        part.code.debugString(buffer);
       } else {
         buffer.write(part.toString());
       }
diff --git a/pkg/_fe_analyzer_shared/test/macros/isolated_executor/isolated_executor_test.dart b/pkg/_fe_analyzer_shared/test/macros/isolated_executor/isolated_executor_test.dart
new file mode 100644
index 0000000..4659971
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/macros/isolated_executor/isolated_executor_test.dart
@@ -0,0 +1,122 @@
+// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:io';
+import 'dart:isolate';
+
+import 'package:_fe_analyzer_shared/src/macros/api.dart';
+import 'package:_fe_analyzer_shared/src/macros/bootstrap.dart';
+import 'package:_fe_analyzer_shared/src/macros/executor.dart';
+import 'package:_fe_analyzer_shared/src/macros/executor_shared/introspection_impls.dart';
+import 'package:_fe_analyzer_shared/src/macros/isolated_executor/isolated_executor.dart'
+    as isolatedExecutor;
+
+import 'package:test/fake.dart';
+import 'package:test/test.dart';
+
+void main() {
+  late MacroExecutor executor;
+  late Directory tmpDir;
+
+  setUp(() async {
+    executor = await isolatedExecutor.start();
+    tmpDir = Directory.systemTemp.createTempSync('isolated_executor_test');
+  });
+
+  tearDown(() {
+    if (tmpDir.existsSync()) tmpDir.deleteSync(recursive: true);
+    executor.close();
+  });
+
+  test('can load macros and create instances', () async {
+    // Tests run from the root of the repo.
+    var macroUri = File('pkg/_fe_analyzer_shared/test/macros/simple_macro.dart')
+        .absolute
+        .uri;
+    var macroName = 'SimpleMacro';
+
+    var bootstrapContent =
+        bootstrapMacroIsolate(macroUri.toString(), macroName, ['', 'named']);
+    var bootstrapFile = File(tmpDir.uri.resolve('main.dart').toFilePath())
+      ..writeAsStringSync(bootstrapContent);
+    var kernelOutputFile =
+        File(tmpDir.uri.resolve('main.dart.dill').toFilePath());
+    var result = await Process.run(Platform.resolvedExecutable, [
+      '--snapshot=${kernelOutputFile.uri.toFilePath()}',
+      '--snapshot-kind=kernel',
+      '--packages=${(await Isolate.packageConfig)!}',
+      bootstrapFile.uri.toFilePath(),
+    ]);
+    expect(result.exitCode, 0,
+        reason: 'stdout: ${result.stdout}\nstderr: ${result.stderr}');
+
+    var clazzId = await executor.loadMacro(macroUri, macroName,
+        precompiledKernelUri: kernelOutputFile.uri);
+    expect(clazzId, isNotNull, reason: 'Can load a macro.');
+
+    var instanceId =
+        await executor.instantiateMacro(clazzId, '', Arguments([], {}));
+    expect(instanceId, isNotNull,
+        reason: 'Can create an instance with no arguments.');
+
+    instanceId =
+        await executor.instantiateMacro(clazzId, '', Arguments([1, 2], {}));
+    expect(instanceId, isNotNull,
+        reason: 'Can create an instance with positional arguments.');
+
+    instanceId = await executor.instantiateMacro(
+        clazzId, 'named', Arguments([], {'x': 1, 'y': 2}));
+    expect(instanceId, isNotNull,
+        reason: 'Can create an instance with named arguments.');
+
+    var definitionResult = await executor.executeDefinitionsPhase(
+        instanceId,
+        FunctionDeclarationImpl(
+          isAbstract: false,
+          isExternal: false,
+          isGetter: false,
+          isSetter: false,
+          name: 'foo',
+          namedParameters: [],
+          positionalParameters: [],
+          returnType: NamedTypeAnnotationImpl(
+              name: 'String', isNullable: false, typeArguments: const []),
+          typeParameters: [],
+        ),
+        _FakeTypeResolver(),
+        _FakeClassIntrospector(),
+        _FakeTypeDeclarationResolver());
+    expect(definitionResult.augmentations, hasLength(1));
+    expect(definitionResult.augmentations.first.debugString().toString(),
+        equalsIgnoringWhitespace('''
+            augment String foo() {
+              print('x: 1, y: 2');
+              return augment super();
+            }'''));
+  });
+}
+
+class _FakeClassIntrospector with Fake implements ClassIntrospector {}
+
+class _FakeTypeResolver with Fake implements TypeResolver {}
+
+class _FakeTypeDeclarationResolver
+    with Fake
+    implements TypeDeclarationResolver {}
+
+extension _ on Code {
+  StringBuffer debugString([StringBuffer? buffer]) {
+    buffer ??= StringBuffer();
+    for (var part in parts) {
+      if (part is Code) {
+        part.debugString(buffer);
+      } else if (part is TypeAnnotation) {
+        part.code.debugString(buffer);
+      } else {
+        buffer.write(part.toString());
+      }
+    }
+    return buffer;
+  }
+}
diff --git a/pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/simple_macro.dart b/pkg/_fe_analyzer_shared/test/macros/simple_macro.dart
similarity index 100%
rename from pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/simple_macro.dart
rename to pkg/_fe_analyzer_shared/test/macros/simple_macro.dart
diff --git a/pkg/analysis_server/lib/src/services/refactoring/rename_local.dart b/pkg/analysis_server/lib/src/services/refactoring/rename_local.dart
index 6fe772e..3bb1fae 100644
--- a/pkg/analysis_server/lib/src/services/refactoring/rename_local.dart
+++ b/pkg/analysis_server/lib/src/services/refactoring/rename_local.dart
@@ -82,9 +82,18 @@
       processor.addDeclarationEdit(element);
       var references = await searchEngine.searchReferences(element);
 
-      // Exclude "implicit" references to optional positional parameters.
-      if (element is ParameterElement && element.isOptionalPositional) {
-        references.removeWhere((match) => match.sourceRange.length == 0);
+      // Remove references that don't have to have the same name.
+      if (element is ParameterElement) {
+        // Implicit references to optional positional parameters.
+        if (element.isOptionalPositional) {
+          references.removeWhere((match) => match.sourceRange.length == 0);
+        }
+        // References to positional parameters from super-formal.
+        if (element.isPositional) {
+          references.removeWhere(
+            (match) => match.element is SuperFormalParameterElement,
+          );
+        }
       }
 
       processor.addReferenceEdits(references);
diff --git a/pkg/analysis_server/test/services/refactoring/rename_local_test.dart b/pkg/analysis_server/test/services/refactoring/rename_local_test.dart
index 5b42916..16a846e 100644
--- a/pkg/analysis_server/test/services/refactoring/rename_local_test.dart
+++ b/pkg/analysis_server/test/services/refactoring/rename_local_test.dart
@@ -565,6 +565,31 @@
 ''');
   }
 
+  Future<void> test_createChange_parameter_named_super() async {
+    await indexTestUnit('''
+class A {
+  A({required int test}); // 0
+}
+class B extends A {
+  B({required super.test});
+}
+''');
+    // configure refactoring
+    createRenameRefactoringAtString('test}); // 0');
+    expect(refactoring.refactoringName, 'Rename Parameter');
+    expect(refactoring.elementKindName, 'parameter');
+    refactoring.newName = 'newName';
+    // validate change
+    return assertSuccessfulRefactoring('''
+class A {
+  A({required int newName}); // 0
+}
+class B extends A {
+  B({required super.newName});
+}
+''');
+  }
+
   Future<void> test_createChange_parameter_named_updateHierarchy() async {
     await indexUnit('$testPackageLibPath/test2.dart', '''
 library test2;
@@ -654,6 +679,33 @@
 ''');
   }
 
+  Future<void> test_createChange_parameter_positional_super() async {
+    await indexTestUnit('''
+class A {
+  A(int test); // 0
+}
+class B extends A {
+  B(super.test);
+}
+''');
+
+    createRenameRefactoringAtString('test); // 0');
+    expect(refactoring.refactoringName, 'Rename Parameter');
+    expect(refactoring.elementKindName, 'parameter');
+    refactoring.newName = 'newName';
+
+    // The name of the super-formal parameter does not have to be the same.
+    // So, we don't rename it.
+    return assertSuccessfulRefactoring('''
+class A {
+  A(int newName); // 0
+}
+class B extends A {
+  B(super.test);
+}
+''');
+  }
+
   Future<void> test_oldName() async {
     await indexTestUnit('''
 void f() {
diff --git a/pkg/analysis_server/test/services/search/search_engine_test.dart b/pkg/analysis_server/test/services/search/search_engine_test.dart
index 07feae1..43637ae 100644
--- a/pkg/analysis_server/test/services/search/search_engine_test.dart
+++ b/pkg/analysis_server/test/services/search/search_engine_test.dart
@@ -344,6 +344,36 @@
     assertHasOne(a, 'a');
   }
 
+  Future<void>
+      test_searchReferences_parameter_ofConstructor_super_named() async {
+    var code = '''
+class A {
+  A({required int a});
+}
+class B extends A {
+  B({required super.a}); // ref
+}
+''';
+    await resolveTestCode(code);
+
+    var element = findElement.unnamedConstructor('A').parameter('a');
+    var matches = await searchEngine.searchReferences(element);
+    expect(
+      matches,
+      unorderedEquals([
+        predicate((SearchMatch m) {
+          return m.kind == MatchKind.REFERENCE &&
+              identical(
+                m.element,
+                findElement.unnamedConstructor('B').superFormalParameter('a'),
+              ) &&
+              m.sourceRange.offset == code.indexOf('a}); // ref') &&
+              m.sourceRange.length == 1;
+        }),
+      ]),
+    );
+  }
+
   Future<void> test_searchTopLevelDeclarations() async {
     newFile('$testPackageLibPath/a.dart', content: '''
 class A {}
diff --git a/pkg/analyzer/CHANGELOG.md b/pkg/analyzer/CHANGELOG.md
index a6f4d42..1d47825 100644
--- a/pkg/analyzer/CHANGELOG.md
+++ b/pkg/analyzer/CHANGELOG.md
@@ -1,6 +1,7 @@
 ## 3.1.0-dev
 * New internal API for `package:dart_style`.
 * Removed deprecated non-API `MockSdk` class.
+* Removed deprecated `AnalysisDriver` constructor.
 
 ## 3.0.0
 * Removed deprecated `DartType.aliasElement/aliasArguments`.
diff --git a/pkg/analyzer/lib/src/clients/build_resolvers/build_resolvers.dart b/pkg/analyzer/lib/src/clients/build_resolvers/build_resolvers.dart
index 9becaf1..be9069c 100644
--- a/pkg/analyzer/lib/src/clients/build_resolvers/build_resolvers.dart
+++ b/pkg/analyzer/lib/src/clients/build_resolvers/build_resolvers.dart
@@ -51,7 +51,7 @@
 
   var logger = PerformanceLog(null);
   var scheduler = AnalysisDriverScheduler(logger);
-  var driver = AnalysisDriver.tmp1(
+  var driver = AnalysisDriver(
     scheduler: scheduler,
     logger: logger,
     resourceProvider: resourceProvider,
diff --git a/pkg/analyzer/lib/src/context/context_root.dart b/pkg/analyzer/lib/src/context/context_root.dart
deleted file mode 100644
index 5155947..0000000
--- a/pkg/analyzer/lib/src/context/context_root.dart
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-import 'package:path/path.dart' as path;
-
-/// Information about the root directory associated with an analysis context.
-///
-/// Clients may not extend, implement or mix-in this class.
-class ContextRoot {
-  /// The path context to use when manipulating paths.
-  final path.Context pathContext;
-
-  /// The absolute path of the root directory containing the files to be
-  /// analyzed.
-  final String root;
-
-  /// A list of the absolute paths of files and directories within the root
-  /// directory that should not be analyzed.
-  final List<String> exclude;
-
-  /// An informative value for the file path that the analysis options were read
-  /// from. This value can be `null` if there is no analysis options file or if
-  /// the location of the file has not yet been discovered.
-  String? optionsFilePath;
-
-  /// Initialize a newly created context root.
-  ContextRoot(this.root, this.exclude, {required this.pathContext});
-
-  @override
-  int get hashCode => Object.hash(root, exclude);
-
-  @override
-  bool operator ==(Object other) {
-    if (other is ContextRoot) {
-      return root == other.root &&
-          _listEqual(exclude, other.exclude, (String a, String b) => a == b);
-    }
-    return false;
-  }
-
-  /// Return `true` if the file with the given [filePath] is contained within
-  /// this context root. A file contained in a context root if it is within the
-  /// context [root] neither explicitly excluded or within one of the excluded
-  /// directories.
-  bool containsFile(String filePath) {
-    if (!pathContext.isWithin(root, filePath)) {
-      return false;
-    }
-    for (String excluded in exclude) {
-      if (filePath == excluded || pathContext.isWithin(excluded, filePath)) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /// Compare the lists [listA] and [listB], using [itemEqual] to compare list
-  /// elements.
-  bool _listEqual<T>(
-      List<T>? listA, List<T>? listB, bool Function(T a, T b) itemEqual) {
-    if (listA == null) {
-      return listB == null;
-    }
-    if (listB == null) {
-      return false;
-    }
-    if (listA.length != listB.length) {
-      return false;
-    }
-    for (int i = 0; i < listA.length; i++) {
-      if (!itemEqual(listA[i], listB[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-}
diff --git a/pkg/analyzer/lib/src/dart/analysis/context_builder.dart b/pkg/analyzer/lib/src/dart/analysis/context_builder.dart
index db6b26d..a9c0df3 100644
--- a/pkg/analyzer/lib/src/dart/analysis/context_builder.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/context_builder.dart
@@ -95,7 +95,7 @@
       updateAnalysisOptions(options);
     }
 
-    var driver = AnalysisDriver.tmp1(
+    var driver = AnalysisDriver(
       scheduler: scheduler,
       logger: performanceLog,
       resourceProvider: resourceProvider,
diff --git a/pkg/analyzer/lib/src/dart/analysis/driver.dart b/pkg/analyzer/lib/src/dart/analysis/driver.dart
index ebc5b48..a63cff8 100644
--- a/pkg/analyzer/lib/src/dart/analysis/driver.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/driver.dart
@@ -14,7 +14,6 @@
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/file_system/file_system.dart';
-import 'package:analyzer/src/context/context_root.dart';
 import 'package:analyzer/src/context/packages.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/feature_set_provider.dart';
@@ -243,42 +242,7 @@
   ///
   /// The given [SourceFactory] is cloned to ensure that it does not contain a
   /// reference to a [AnalysisContext] in which it could have been used.
-  @Deprecated('Use AnalysisDriver.tmp1() instead')
-  factory AnalysisDriver(
-    AnalysisDriverScheduler scheduler,
-    PerformanceLog logger,
-    ResourceProvider resourceProvider,
-    ByteStore byteStore,
-    // ignore: avoid_unused_constructor_parameters
-    FileContentOverlay? contentOverlay,
-    // ignore: avoid_unused_constructor_parameters
-    ContextRoot? contextRoot,
-    SourceFactory sourceFactory,
-    AnalysisOptionsImpl analysisOptions, {
-    Packages? packages,
-    bool enableIndex = false,
-    SummaryDataStore? externalSummaries,
-    bool retainDataForTesting = false,
-  }) {
-    return AnalysisDriver.tmp1(
-      scheduler: scheduler,
-      logger: logger,
-      resourceProvider: resourceProvider,
-      byteStore: byteStore,
-      sourceFactory: sourceFactory,
-      analysisOptions: analysisOptions,
-      packages: packages ?? Packages.empty,
-      enableIndex: enableIndex,
-      externalSummaries: externalSummaries,
-      retainDataForTesting: retainDataForTesting,
-    );
-  }
-
-  /// Create a new instance of [AnalysisDriver].
-  ///
-  /// The given [SourceFactory] is cloned to ensure that it does not contain a
-  /// reference to a [AnalysisContext] in which it could have been used.
-  AnalysisDriver.tmp1({
+  AnalysisDriver({
     required AnalysisDriverScheduler scheduler,
     required PerformanceLog logger,
     required ResourceProvider resourceProvider,
@@ -309,6 +273,37 @@
     _search = Search(this);
   }
 
+  /// Create a new instance of [AnalysisDriver].
+  ///
+  /// The given [SourceFactory] is cloned to ensure that it does not contain a
+  /// reference to a [AnalysisContext] in which it could have been used.
+  @Deprecated('Use the unnamed constructor instead')
+  AnalysisDriver.tmp1({
+    required AnalysisDriverScheduler scheduler,
+    required PerformanceLog logger,
+    required ResourceProvider resourceProvider,
+    required ByteStore byteStore,
+    required SourceFactory sourceFactory,
+    required AnalysisOptionsImpl analysisOptions,
+    required Packages packages,
+    FileContentCache? fileContentCache,
+    bool enableIndex = false,
+    SummaryDataStore? externalSummaries,
+    bool retainDataForTesting = false,
+  }) : this(
+          scheduler: scheduler,
+          logger: logger,
+          resourceProvider: resourceProvider,
+          byteStore: byteStore,
+          sourceFactory: sourceFactory,
+          analysisOptions: analysisOptions,
+          packages: packages,
+          fileContentCache: fileContentCache,
+          enableIndex: enableIndex,
+          externalSummaries: externalSummaries,
+          retainDataForTesting: retainDataForTesting,
+        );
+
   /// Return the set of files explicitly added to analysis using [addFile].
   Set<String> get addedFiles => _fileTracker.addedFiles;
 
diff --git a/pkg/analyzer/lib/src/dart/analysis/experiments.g.dart b/pkg/analyzer/lib/src/dart/analysis/experiments.g.dart
index 1fda845..9cda58d 100644
--- a/pkg/analyzer/lib/src/dart/analysis/experiments.g.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/experiments.g.dart
@@ -8,7 +8,7 @@
 
 /// The current version of the Dart language (or, for non-stable releases, the
 /// version of the language currently in the process of being developed).
-const _currentVersion = '2.16.0';
+const _currentVersion = '2.17.0';
 
 /// A map containing information about all known experimental flags.
 final _knownFeatures = <String, ExperimentalFeature>{
diff --git a/pkg/analyzer/lib/src/dart/analysis/index.dart b/pkg/analyzer/lib/src/dart/analysis/index.dart
index 9ce7dda..8be9a88 100644
--- a/pkg/analyzer/lib/src/dart/analysis/index.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/index.dart
@@ -836,6 +836,20 @@
   }
 
   @override
+  visitSuperFormalParameter(SuperFormalParameter node) {
+    var element = node.declaredElement;
+    if (element is SuperFormalParameterElementImpl) {
+      var superParameter = element.superConstructorParameter;
+      if (superParameter != null) {
+        recordRelation(superParameter, IndexRelationKind.IS_REFERENCED_BY,
+            node.identifier, true);
+      }
+    }
+
+    return super.visitSuperFormalParameter(node);
+  }
+
+  @override
   void visitWithClause(WithClause node) {
     for (NamedType namedType in node.mixinTypes2) {
       recordSuperType(namedType, IndexRelationKind.IS_MIXED_IN_BY);
diff --git a/pkg/analyzer/lib/src/dart/analysis/search.dart b/pkg/analyzer/lib/src/dart/analysis/search.dart
index 651e0f9..cdd7c72 100644
--- a/pkg/analyzer/lib/src/dart/analysis/search.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/search.dart
@@ -682,7 +682,9 @@
       },
       searchedFiles,
     ));
-    if (parameter.isNamed || parameter.isOptionalPositional) {
+    if (parameter.isNamed ||
+        parameter.isOptionalPositional ||
+        parameter.enclosingElement is ConstructorElement) {
       results.addAll(await _searchReferences(parameter, searchedFiles));
     }
     return results;
diff --git a/pkg/analyzer/lib/src/summary2/default_types_builder.dart b/pkg/analyzer/lib/src/summary2/default_types_builder.dart
index d565a18..d74903b 100644
--- a/pkg/analyzer/lib/src/summary2/default_types_builder.dart
+++ b/pkg/analyzer/lib/src/summary2/default_types_builder.dart
@@ -246,7 +246,6 @@
           void recurseParameters(List<TypeParameterElement> parameters) {
             for (var parameter in parameters) {
               var parameterNode = _linker.getLinkingNode(parameter);
-              // TODO(scheglov) How to we skip already linked?
               if (parameterNode is TypeParameter) {
                 var bound = parameterNode.bound;
                 if (bound != null) {
diff --git a/pkg/analyzer/lib/src/test_utilities/find_element.dart b/pkg/analyzer/lib/src/test_utilities/find_element.dart
index 8a894ec..75a6db5 100644
--- a/pkg/analyzer/lib/src/test_utilities/find_element.dart
+++ b/pkg/analyzer/lib/src/test_utilities/find_element.dart
@@ -638,6 +638,15 @@
 }
 
 extension ExecutableElementExtensions on ExecutableElement {
+  ParameterElement parameter(String name) {
+    for (var parameter in parameters) {
+      if (parameter.name == name) {
+        return parameter;
+      }
+    }
+    throw StateError('Not found: $name');
+  }
+
   SuperFormalParameterElement superFormalParameter(String name) {
     for (var parameter in parameters) {
       if (parameter is SuperFormalParameterElement && parameter.name == name) {
diff --git a/pkg/analyzer/test/src/dart/analysis/base.dart b/pkg/analyzer/test/src/dart/analysis/base.dart
index b6c9542..4ed178b 100644
--- a/pkg/analyzer/test/src/dart/analysis/base.dart
+++ b/pkg/analyzer/test/src/dart/analysis/base.dart
@@ -57,7 +57,7 @@
       'aaa': [getFolder('/aaa/lib')],
       'bbb': [getFolder('/bbb/lib')],
     };
-    return AnalysisDriver.tmp1(
+    return AnalysisDriver(
       scheduler: scheduler,
       logger: logger,
       resourceProvider: resourceProvider,
diff --git a/pkg/analyzer/test/src/dart/analysis/driver_test.dart b/pkg/analyzer/test/src/dart/analysis/driver_test.dart
index cb4869d..1f83aec 100644
--- a/pkg/analyzer/test/src/dart/analysis/driver_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/driver_test.dart
@@ -116,7 +116,7 @@
 
   AnalysisDriver newDriver() {
     var sdk = FolderBasedDartSdk(resourceProvider, sdkRoot);
-    AnalysisDriver driver = AnalysisDriver.tmp1(
+    AnalysisDriver driver = AnalysisDriver(
       scheduler: scheduler,
       logger: logger,
       resourceProvider: resourceProvider,
diff --git a/pkg/analyzer/test/src/dart/analysis/index_test.dart b/pkg/analyzer/test/src/dart/analysis/index_test.dart
index 29798f2..9375dc1 100644
--- a/pkg/analyzer/test/src/dart/analysis/index_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/index_test.dart
@@ -1115,6 +1115,32 @@
     // No exceptions.
   }
 
+  test_isReferencedBy_ParameterElement_ofConstructor_super_named() async {
+    await _indexTestUnit('''
+class A {
+  A({required int a});
+}
+class B extends A {
+  B({required super.a}); // ref
+}
+''');
+    var element = findElement.unnamedConstructor('A').parameter('a');
+    assertThat(element)..isReferencedAt('a}); // ref', true);
+  }
+
+  test_isReferencedBy_ParameterElement_ofConstructor_super_positional() async {
+    await _indexTestUnit('''
+class A {
+  A(int a);
+}
+class B extends A {
+  B(super.a); // ref
+}
+''');
+    var element = findElement.unnamedConstructor('A').parameter('a');
+    assertThat(element)..isReferencedAt('a); // ref', true);
+  }
+
   test_isReferencedBy_ParameterElement_optionalNamed_ofConstructor_genericClass() async {
     await _indexTestUnit('''
 class A<T> {
diff --git a/pkg/analyzer/test/src/dart/analysis/search_test.dart b/pkg/analyzer/test/src/dart/analysis/search_test.dart
index 91057d0..8e54e31 100644
--- a/pkg/analyzer/test/src/dart/analysis/search_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/search_test.dart
@@ -7,6 +7,7 @@
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer/src/dart/analysis/search.dart';
+import 'package:analyzer/src/test_utilities/find_element.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
@@ -1392,6 +1393,46 @@
     await _verifyReferences(method, expected);
   }
 
+  test_searchReferences_ParameterElement_ofConstructor_super_named() async {
+    await resolveTestCode('''
+class A {
+  A({required int a});
+}
+class B extends A {
+  B({required super.a}); // ref
+}
+''');
+    var element = findElement.unnamedConstructor('A').parameter('a');
+    var expected = [
+      _expectIdQ(
+        findElement.unnamedConstructor('B').superFormalParameter('a'),
+        SearchResultKind.REFERENCE,
+        'a}); // ref',
+      ),
+    ];
+    await _verifyReferences(element, expected);
+  }
+
+  test_searchReferences_ParameterElement_ofConstructor_super_positional() async {
+    await resolveTestCode('''
+class A {
+  A(int a);
+}
+class B extends A {
+  B(super.a); // ref
+}
+''');
+    var element = findElement.unnamedConstructor('A').parameter('a');
+    var expected = [
+      _expectIdQ(
+        findElement.unnamedConstructor('B').superFormalParameter('a'),
+        SearchResultKind.REFERENCE,
+        'a); // ref',
+      ),
+    ];
+    await _verifyReferences(element, expected);
+  }
+
   test_searchReferences_ParameterElement_optionalNamed() async {
     await resolveTestCode('''
 foo({p}) {
diff --git a/pkg/analyzer/test/util/id_testing_helper.dart b/pkg/analyzer/test/util/id_testing_helper.dart
index 7fe6cbe..d39b7db 100644
--- a/pkg/analyzer/test/util/id_testing_helper.dart
+++ b/pkg/analyzer/test/util/id_testing_helper.dart
@@ -145,7 +145,7 @@
   var byteStore = MemoryByteStore();
   var analysisOptions = AnalysisOptionsImpl()
     ..contextFeatures = config.featureSet;
-  var driver = AnalysisDriver.tmp1(
+  var driver = AnalysisDriver(
     scheduler: scheduler,
     logger: logger,
     resourceProvider: resourceProvider,
diff --git a/pkg/dartdev/test/utils.dart b/pkg/dartdev/test/utils.dart
index 8f8147a..b45e60b 100644
--- a/pkg/dartdev/test/utils.dart
+++ b/pkg/dartdev/test/utils.dart
@@ -97,8 +97,17 @@
     _process?.kill();
     await _process?.exitCode;
     _process = null;
-    if (dir.existsSync()) {
-      dir.deleteSync(recursive: true);
+    int deleteAttempts = 5;
+    while (dir.existsSync()) {
+      try {
+        dir.deleteSync(recursive: true);
+      } catch (e) {
+        if ((--deleteAttempts) <= 0) {
+          rethrow;
+        }
+        await Future.delayed(Duration(milliseconds: 500));
+        print('Got $e while deleting $dir. Trying again...');
+      }
     }
   }
 
diff --git a/pkg/dds/CHANGELOG.md b/pkg/dds/CHANGELOG.md
index 3b33fd2..03a0044 100644
--- a/pkg/dds/CHANGELOG.md
+++ b/pkg/dds/CHANGELOG.md
@@ -1,3 +1,15 @@
+# 2.1.7
+- Re-release 2.1.6+1.
+
+# 2.1.6+3
+- Roll back to 2.1.4.
+
+# 2.1.6+2
+- Roll back to 2.1.5.
+
+# 2.1.6+1
+- Fix dependencies.
+
 # 2.1.6
 - Improve performance of CPU sample caching.
 
diff --git a/pkg/dds/lib/vm_service_extensions.dart b/pkg/dds/lib/vm_service_extensions.dart
index 536fa57..7c9a031 100644
--- a/pkg/dds/lib/vm_service_extensions.dart
+++ b/pkg/dds/lib/vm_service_extensions.dart
@@ -2,275 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-import 'dart:async';
-import 'dart:collection';
+@Deprecated("Use 'package:dds_service_extensions' instead")
+library vm_service_extensions;
 
-import 'package:async/async.dart';
-import 'package:pedantic/pedantic.dart';
-import 'package:vm_service/src/vm_service.dart';
-
-extension DdsExtension on VmService {
-  static bool _factoriesRegistered = false;
-  static Version? _ddsVersion;
-
-  /// The [getDartDevelopmentServiceVersion] RPC is used to determine what version of
-  /// the Dart Development Service Protocol is served by a DDS instance.
-  ///
-  /// The result of this call is cached for subsequent invocations.
-  Future<Version> getDartDevelopmentServiceVersion() async {
-    if (_ddsVersion == null) {
-      _ddsVersion = await _callHelper<Version>(
-        'getDartDevelopmentServiceVersion',
-      );
-    }
-    return _ddsVersion!;
-  }
-
-  /// The [getCachedCpuSamples] RPC is used to retrieve a cache of CPU samples
-  /// collected under a [UserTag] with name `userTag`.
-  Future<CachedCpuSamples> getCachedCpuSamples(
-      String isolateId, String userTag) async {
-    if (!(await _versionCheck(1, 3))) {
-      throw UnimplementedError('getCachedCpuSamples requires DDS version 1.3');
-    }
-    return _callHelper<CachedCpuSamples>('getCachedCpuSamples', args: {
-      'isolateId': isolateId,
-      'userTag': userTag,
-    });
-  }
-
-  /// The [getAvailableCachedCpuSamples] RPC is used to determine which caches of CPU samples
-  /// are available. Caches are associated with individual [UserTag] names and are specified
-  /// when DDS is started via the `cachedUserTags` parameter.
-  Future<AvailableCachedCpuSamples> getAvailableCachedCpuSamples() async {
-    if (!(await _versionCheck(1, 3))) {
-      throw UnimplementedError(
-        'getAvailableCachedCpuSamples requires DDS version 1.3',
-      );
-    }
-    return _callHelper<AvailableCachedCpuSamples>(
-      'getAvailableCachedCpuSamples',
-    );
-  }
-
-  /// Retrieve the event history for `stream`.
-  ///
-  /// If `stream` does not have event history collected, a parameter error is
-  /// returned.
-  Future<StreamHistory> getStreamHistory(String stream) async {
-    if (!(await _versionCheck(1, 2))) {
-      throw UnimplementedError('getStreamHistory requires DDS version 1.2');
-    }
-    return _callHelper<StreamHistory>('getStreamHistory', args: {
-      'stream': stream,
-    });
-  }
-
-  /// Returns the stream for a given stream id which includes historical
-  /// events.
-  ///
-  /// If `stream` does not have event history collected, a parameter error is
-  /// sent over the returned [Stream].
-  Stream<Event> onEventWithHistory(String stream) {
-    late StreamController<Event> controller;
-    late StreamQueue<Event> streamEvents;
-
-    controller = StreamController<Event>(onListen: () async {
-      streamEvents = StreamQueue<Event>(onEvent(stream));
-      final history = (await getStreamHistory(stream)).history;
-      Event? firstStreamEvent;
-      unawaited(streamEvents.peek.then((e) {
-        firstStreamEvent = e;
-      }));
-      for (final event in history) {
-        if (firstStreamEvent != null &&
-            event.timestamp! > firstStreamEvent!.timestamp!) {
-          break;
-        }
-        controller.sink.add(event);
-      }
-      unawaited(controller.sink.addStream(streamEvents.rest));
-    }, onCancel: () {
-      try {
-        streamEvents.cancel();
-      } on StateError {
-        // Underlying stream may have already been cancelled.
-      }
-    });
-
-    return controller.stream;
-  }
-
-  /// Returns a new [Stream<Event>] of `Logging` events which outputs
-  /// historical events before streaming real-time events.
-  ///
-  /// Note: unlike [onLoggingEvent], the returned stream is a single
-  /// subscription stream and a new stream is created for each invocation of
-  /// this getter.
-  Stream<Event> get onLoggingEventWithHistory => onEventWithHistory('Logging');
-
-  /// Returns a new [Stream<Event>] of `Stdout` events which outputs
-  /// historical events before streaming real-time events.
-  ///
-  /// Note: unlike [onStdoutEvent], the returned stream is a single
-  /// subscription stream and a new stream is created for each invocation of
-  /// this getter.
-  Stream<Event> get onStdoutEventWithHistory => onEventWithHistory('Stdout');
-
-  /// Returns a new [Stream<Event>] of `Stderr` events which outputs
-  /// historical events before streaming real-time events.
-  ///
-  /// Note: unlike [onStderrEvent], the returned stream is a single
-  /// subscription stream and a new stream is created for each invocation of
-  /// this getter.
-  Stream<Event> get onStderrEventWithHistory => onEventWithHistory('Stderr');
-
-  /// Returns a new [Stream<Event>] of `Extension` events which outputs
-  /// historical events before streaming real-time events.
-  ///
-  /// Note: unlike [onExtensionEvent], the returned stream is a single
-  /// subscription stream and a new stream is created for each invocation of
-  /// this getter.
-  Stream<Event> get onExtensionEventWithHistory =>
-      onEventWithHistory('Extension');
-
-  Future<bool> _versionCheck(int major, int minor) async {
-    if (_ddsVersion == null) {
-      _ddsVersion = await getDartDevelopmentServiceVersion();
-    }
-    return ((_ddsVersion!.major == major && _ddsVersion!.minor! >= minor) ||
-        (_ddsVersion!.major! > major));
-  }
-
-  Future<T> _callHelper<T>(String method,
-      {String? isolateId, Map args = const {}}) {
-    if (!_factoriesRegistered) {
-      _registerFactories();
-    }
-    return callMethod(
-      method,
-      args: {
-        if (isolateId != null) 'isolateId': isolateId,
-        ...args,
-      },
-    ).then((e) => e as T);
-  }
-
-  static void _registerFactories() {
-    addTypeFactory('StreamHistory', StreamHistory.parse);
-    addTypeFactory(
-      'AvailableCachedCpuSamples',
-      AvailableCachedCpuSamples.parse,
-    );
-    addTypeFactory('CachedCpuSamples', CachedCpuSamples.parse);
-    _factoriesRegistered = true;
-  }
-}
-
-/// A collection of historical [Event]s from some stream.
-class StreamHistory extends Response {
-  static StreamHistory? parse(Map<String, dynamic>? json) =>
-      json == null ? null : StreamHistory._fromJson(json);
-
-  StreamHistory({required List<Event> history}) : _history = history;
-
-  StreamHistory._fromJson(Map<String, dynamic> json)
-      : _history = json['history']
-            .map(
-              (e) => Event.parse(e),
-            )
-            .toList()
-            .cast<Event>() {
-    this.json = json;
-  }
-
-  @override
-  String get type => 'StreamHistory';
-
-  /// Historical [Event]s for a stream.
-  List<Event> get history => UnmodifiableListView(_history);
-  final List<Event> _history;
-}
-
-/// An extension of [CpuSamples] which represents a set of cached samples,
-/// associated with a particular [UserTag] name.
-class CachedCpuSamples extends CpuSamples {
-  static CachedCpuSamples? parse(Map<String, dynamic>? json) =>
-      json == null ? null : CachedCpuSamples._fromJson(json);
-
-  CachedCpuSamples({
-    required this.userTag,
-    this.truncated,
-    required int? samplePeriod,
-    required int? maxStackDepth,
-    required int? sampleCount,
-    required int? timeSpan,
-    required int? timeOriginMicros,
-    required int? timeExtentMicros,
-    required int? pid,
-    required List<ProfileFunction>? functions,
-    required List<CpuSample>? samples,
-  }) : super(
-          samplePeriod: samplePeriod,
-          maxStackDepth: maxStackDepth,
-          sampleCount: sampleCount,
-          timeSpan: timeSpan,
-          timeOriginMicros: timeOriginMicros,
-          timeExtentMicros: timeExtentMicros,
-          pid: pid,
-          functions: functions,
-          samples: samples,
-        );
-
-  CachedCpuSamples._fromJson(Map<String, dynamic> json)
-      : userTag = json['userTag']!,
-        truncated = json['truncated'],
-        super(
-          samplePeriod: json['samplePeriod'] ?? -1,
-          maxStackDepth: json['maxStackDepth'] ?? -1,
-          sampleCount: json['sampleCount'] ?? -1,
-          timeSpan: json['timeSpan'] ?? -1,
-          timeOriginMicros: json['timeOriginMicros'] ?? -1,
-          timeExtentMicros: json['timeExtentMicros'] ?? -1,
-          pid: json['pid'] ?? -1,
-          functions: List<ProfileFunction>.from(
-            createServiceObject(json['functions'], const ['ProfileFunction'])
-                    as List? ??
-                [],
-          ),
-          samples: List<CpuSample>.from(
-            createServiceObject(json['samples'], const ['CpuSample'])
-                    as List? ??
-                [],
-          ),
-        );
-
-  @override
-  String get type => 'CachedCpuSamples';
-
-  /// The name of the [UserTag] associated with this cache of [CpuSamples].
-  final String userTag;
-
-  /// Provided if the CPU sample cache has filled and older samples have been
-  /// dropped.
-  final bool? truncated;
-}
-
-/// A collection of [UserTag] names associated with caches of CPU samples.
-class AvailableCachedCpuSamples extends Response {
-  static AvailableCachedCpuSamples? parse(Map<String, dynamic>? json) =>
-      json == null ? null : AvailableCachedCpuSamples._fromJson(json);
-
-  AvailableCachedCpuSamples({
-    required this.cacheNames,
-  });
-
-  AvailableCachedCpuSamples._fromJson(Map<String, dynamic> json)
-      : cacheNames = List<String>.from(json['cacheNames']);
-
-  @override
-  String get type => 'AvailableCachedUserTagCpuSamples';
-
-  /// A [List] of [UserTag] names associated with CPU sample caches.
-  final List<String> cacheNames;
-}
+export 'package:dds_service_extensions/dds_service_extensions.dart';
diff --git a/pkg/dds/pubspec.yaml b/pkg/dds/pubspec.yaml
index bc3e130..92adad1 100644
--- a/pkg/dds/pubspec.yaml
+++ b/pkg/dds/pubspec.yaml
@@ -3,7 +3,7 @@
   A library used to spawn the Dart Developer Service, used to communicate with
   a Dart VM Service instance.
 
-version: 2.1.6
+version: 2.1.7
 
 homepage: https://github.com/dart-lang/sdk/tree/master/pkg/dds
 
@@ -13,6 +13,7 @@
 dependencies:
   async: ^2.4.1
   collection: ^1.15.0
+  dds_service_extensions: ^1.3.0
   devtools_shared: ^2.3.0
   json_rpc_2: ^3.0.0
   meta: ^1.1.8
@@ -24,7 +25,7 @@
   shelf_web_socket: ^1.0.0
   sse: ^4.0.0
   stream_channel: ^2.0.0
-  vm_service: ^7.5.0
+  vm_service: ^8.1.0
   web_socket_channel: ^2.0.0
 
 dev_dependencies:
diff --git a/pkg/dds/test/get_cached_cpu_samples_test.dart b/pkg/dds/test/get_cached_cpu_samples_test.dart
index ae25095..57ce1bc 100644
--- a/pkg/dds/test/get_cached_cpu_samples_test.dart
+++ b/pkg/dds/test/get_cached_cpu_samples_test.dart
@@ -7,7 +7,7 @@
 
 import 'package:dds/dds.dart';
 import 'package:dds/src/utils/mutex.dart';
-import 'package:dds/vm_service_extensions.dart';
+import 'package:dds_service_extensions/dds_service_extensions.dart';
 import 'package:test/test.dart';
 import 'package:vm_service/vm_service.dart';
 import 'package:vm_service/vm_service_io.dart';
diff --git a/pkg/dds/test/get_stream_history_test.dart b/pkg/dds/test/get_stream_history_test.dart
index 101ae0c..efdaf2e 100644
--- a/pkg/dds/test/get_stream_history_test.dart
+++ b/pkg/dds/test/get_stream_history_test.dart
@@ -5,7 +5,7 @@
 import 'dart:io';
 
 import 'package:dds/dds.dart';
-import 'package:dds/vm_service_extensions.dart';
+import 'package:dds_service_extensions/dds_service_extensions.dart';
 import 'package:test/test.dart';
 import 'package:vm_service/vm_service_io.dart';
 import 'common/test_helper.dart';
diff --git a/pkg/dds/test/on_event_with_history_test.dart b/pkg/dds/test/on_event_with_history_test.dart
index 01d2fd3..5365b03 100644
--- a/pkg/dds/test/on_event_with_history_test.dart
+++ b/pkg/dds/test/on_event_with_history_test.dart
@@ -6,7 +6,7 @@
 import 'dart:io';
 
 import 'package:dds/dds.dart';
-import 'package:dds/vm_service_extensions.dart';
+import 'package:dds_service_extensions/dds_service_extensions.dart';
 import 'package:test/test.dart';
 import 'package:vm_service/vm_service_io.dart';
 import 'common/test_helper.dart';
diff --git a/pkg/dds/test/regress_devtools_issue_3302_test.dart b/pkg/dds/test/regress_devtools_issue_3302_test.dart
index 8c97a12..4d9c458 100644
--- a/pkg/dds/test/regress_devtools_issue_3302_test.dart
+++ b/pkg/dds/test/regress_devtools_issue_3302_test.dart
@@ -6,7 +6,7 @@
 import 'dart:io';
 
 import 'package:dds/dds.dart';
-import 'package:dds/vm_service_extensions.dart';
+import 'package:dds_service_extensions/dds_service_extensions.dart';
 import 'package:test/test.dart';
 import 'package:vm_service/vm_service_io.dart';
 import 'common/test_helper.dart';
diff --git a/pkg/dds_service_extensions/.gitignore b/pkg/dds_service_extensions/.gitignore
new file mode 100644
index 0000000..65c34dc
--- /dev/null
+++ b/pkg/dds_service_extensions/.gitignore
@@ -0,0 +1,10 @@
+# Files and directories created by pub.
+.dart_tool/
+.packages
+
+# Conventional directory for build outputs.
+build/
+
+# Omit committing pubspec.lock for library packages; see
+# https://dart.dev/guides/libraries/private-files#pubspeclock.
+pubspec.lock
diff --git a/pkg/dds_service_extensions/CHANGELOG.md b/pkg/dds_service_extensions/CHANGELOG.md
new file mode 100644
index 0000000..0290ebf
--- /dev/null
+++ b/pkg/dds_service_extensions/CHANGELOG.md
@@ -0,0 +1,3 @@
+## 1.3.0
+
+- Moved `package:dds/vm_service_extensions.dart` into a standalone package.
diff --git a/pkg/dds_service_extensions/README.md b/pkg/dds_service_extensions/README.md
new file mode 100644
index 0000000..9f50e4f
--- /dev/null
+++ b/pkg/dds_service_extensions/README.md
@@ -0,0 +1,3 @@
+A package used to expand the `package:vm_service` interface with support for RPCs added in the [Dart Developer Service (DDS) protocol][dds-protocol].
+
+[dds-protocol]: https://github.com/dart-lang/sdk/blob/main/pkg/dds/dds_protocol.md
diff --git a/pkg/dds_service_extensions/analysis_options.yaml b/pkg/dds_service_extensions/analysis_options.yaml
new file mode 100644
index 0000000..dee8927
--- /dev/null
+++ b/pkg/dds_service_extensions/analysis_options.yaml
@@ -0,0 +1,30 @@
+# This file configures the static analysis results for your project (errors,
+# warnings, and lints).
+#
+# This enables the 'recommended' set of lints from `package:lints`.
+# This set helps identify many issues that may lead to problems when running
+# or consuming Dart code, and enforces writing Dart using a single, idiomatic
+# style and format.
+#
+# If you want a smaller set of lints you can change this to specify
+# 'package:lints/core.yaml'. These are just the most critical lints
+# (the recommended set includes the core lints).
+# The core lints are also what is used by pub.dev for scoring packages.
+
+include: package:lints/recommended.yaml
+
+# Uncomment the following section to specify additional rules.
+
+# linter:
+#   rules:
+#     - camel_case_types
+
+# analyzer:
+#   exclude:
+#     - path/to/excluded/files/**
+
+# For more information about the core and recommended set of lints, see
+# https://dart.dev/go/core-lints
+
+# For additional information about configuring this file, see
+# https://dart.dev/guides/language/analysis-options
diff --git a/pkg/dds_service_extensions/lib/dds_service_extensions.dart b/pkg/dds_service_extensions/lib/dds_service_extensions.dart
new file mode 100644
index 0000000..702cf58
--- /dev/null
+++ b/pkg/dds_service_extensions/lib/dds_service_extensions.dart
@@ -0,0 +1,272 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:collection';
+
+import 'package:async/async.dart';
+// ignore: implementation_imports
+import 'package:vm_service/src/vm_service.dart';
+
+extension DdsExtension on VmService {
+  static bool _factoriesRegistered = false;
+  static Version? _ddsVersion;
+
+  /// The [getDartDevelopmentServiceVersion] RPC is used to determine what version of
+  /// the Dart Development Service Protocol is served by a DDS instance.
+  ///
+  /// The result of this call is cached for subsequent invocations.
+  Future<Version> getDartDevelopmentServiceVersion() async {
+    _ddsVersion ??= await _callHelper<Version>(
+      'getDartDevelopmentServiceVersion',
+    );
+    return _ddsVersion!;
+  }
+
+  /// The [getCachedCpuSamples] RPC is used to retrieve a cache of CPU samples
+  /// collected under a [UserTag] with name `userTag`.
+  Future<CachedCpuSamples> getCachedCpuSamples(
+      String isolateId, String userTag) async {
+    if (!(await _versionCheck(1, 3))) {
+      throw UnimplementedError('getCachedCpuSamples requires DDS version 1.3');
+    }
+    return _callHelper<CachedCpuSamples>('getCachedCpuSamples', args: {
+      'isolateId': isolateId,
+      'userTag': userTag,
+    });
+  }
+
+  /// The [getAvailableCachedCpuSamples] RPC is used to determine which caches of CPU samples
+  /// are available. Caches are associated with individual [UserTag] names and are specified
+  /// when DDS is started via the `cachedUserTags` parameter.
+  Future<AvailableCachedCpuSamples> getAvailableCachedCpuSamples() async {
+    if (!(await _versionCheck(1, 3))) {
+      throw UnimplementedError(
+        'getAvailableCachedCpuSamples requires DDS version 1.3',
+      );
+    }
+    return _callHelper<AvailableCachedCpuSamples>(
+      'getAvailableCachedCpuSamples',
+    );
+  }
+
+  /// Retrieve the event history for `stream`.
+  ///
+  /// If `stream` does not have event history collected, a parameter error is
+  /// returned.
+  Future<StreamHistory> getStreamHistory(String stream) async {
+    if (!(await _versionCheck(1, 2))) {
+      throw UnimplementedError('getStreamHistory requires DDS version 1.2');
+    }
+    return _callHelper<StreamHistory>('getStreamHistory', args: {
+      'stream': stream,
+    });
+  }
+
+  /// Returns the stream for a given stream id which includes historical
+  /// events.
+  ///
+  /// If `stream` does not have event history collected, a parameter error is
+  /// sent over the returned [Stream].
+  Stream<Event> onEventWithHistory(String stream) {
+    late StreamController<Event> controller;
+    late StreamQueue<Event> streamEvents;
+
+    controller = StreamController<Event>(onListen: () async {
+      streamEvents = StreamQueue<Event>(onEvent(stream));
+      final history = (await getStreamHistory(stream)).history;
+      Event? firstStreamEvent;
+      unawaited(streamEvents.peek.then((e) {
+        firstStreamEvent = e;
+      }));
+      for (final event in history) {
+        if (firstStreamEvent != null &&
+            event.timestamp! > firstStreamEvent!.timestamp!) {
+          break;
+        }
+        controller.sink.add(event);
+      }
+      unawaited(controller.sink.addStream(streamEvents.rest));
+    }, onCancel: () {
+      try {
+        streamEvents.cancel();
+      } on StateError {
+        // Underlying stream may have already been cancelled.
+      }
+    });
+
+    return controller.stream;
+  }
+
+  /// Returns a new [Stream<Event>] of `Logging` events which outputs
+  /// historical events before streaming real-time events.
+  ///
+  /// Note: unlike [onLoggingEvent], the returned stream is a single
+  /// subscription stream and a new stream is created for each invocation of
+  /// this getter.
+  Stream<Event> get onLoggingEventWithHistory => onEventWithHistory('Logging');
+
+  /// Returns a new [Stream<Event>] of `Stdout` events which outputs
+  /// historical events before streaming real-time events.
+  ///
+  /// Note: unlike [onStdoutEvent], the returned stream is a single
+  /// subscription stream and a new stream is created for each invocation of
+  /// this getter.
+  Stream<Event> get onStdoutEventWithHistory => onEventWithHistory('Stdout');
+
+  /// Returns a new [Stream<Event>] of `Stderr` events which outputs
+  /// historical events before streaming real-time events.
+  ///
+  /// Note: unlike [onStderrEvent], the returned stream is a single
+  /// subscription stream and a new stream is created for each invocation of
+  /// this getter.
+  Stream<Event> get onStderrEventWithHistory => onEventWithHistory('Stderr');
+
+  /// Returns a new [Stream<Event>] of `Extension` events which outputs
+  /// historical events before streaming real-time events.
+  ///
+  /// Note: unlike [onExtensionEvent], the returned stream is a single
+  /// subscription stream and a new stream is created for each invocation of
+  /// this getter.
+  Stream<Event> get onExtensionEventWithHistory =>
+      onEventWithHistory('Extension');
+
+  Future<bool> _versionCheck(int major, int minor) async {
+    _ddsVersion ??= await getDartDevelopmentServiceVersion();
+    return ((_ddsVersion!.major == major && _ddsVersion!.minor! >= minor) ||
+        (_ddsVersion!.major! > major));
+  }
+
+  Future<T> _callHelper<T>(String method,
+      {String? isolateId, Map args = const {}}) {
+    if (!_factoriesRegistered) {
+      _registerFactories();
+    }
+    return callMethod(
+      method,
+      args: {
+        if (isolateId != null) 'isolateId': isolateId,
+        ...args,
+      },
+    ).then((e) => e as T);
+  }
+
+  static void _registerFactories() {
+    addTypeFactory('StreamHistory', StreamHistory.parse);
+    addTypeFactory(
+      'AvailableCachedCpuSamples',
+      AvailableCachedCpuSamples.parse,
+    );
+    addTypeFactory('CachedCpuSamples', CachedCpuSamples.parse);
+    _factoriesRegistered = true;
+  }
+}
+
+/// A collection of historical [Event]s from some stream.
+class StreamHistory extends Response {
+  static StreamHistory? parse(Map<String, dynamic>? json) =>
+      json == null ? null : StreamHistory._fromJson(json);
+
+  StreamHistory({required List<Event> history}) : _history = history;
+
+  StreamHistory._fromJson(Map<String, dynamic> json)
+      : _history = json['history']
+            .map(
+              (e) => Event.parse(e),
+            )
+            .toList()
+            .cast<Event>() {
+    this.json = json;
+  }
+
+  @override
+  String get type => 'StreamHistory';
+
+  /// Historical [Event]s for a stream.
+  List<Event> get history => UnmodifiableListView(_history);
+  final List<Event> _history;
+}
+
+/// An extension of [CpuSamples] which represents a set of cached samples,
+/// associated with a particular [UserTag] name.
+class CachedCpuSamples extends CpuSamples {
+  static CachedCpuSamples? parse(Map<String, dynamic>? json) =>
+      json == null ? null : CachedCpuSamples._fromJson(json);
+
+  CachedCpuSamples({
+    required this.userTag,
+    this.truncated,
+    required int? samplePeriod,
+    required int? maxStackDepth,
+    required int? sampleCount,
+    required int? timeSpan,
+    required int? timeOriginMicros,
+    required int? timeExtentMicros,
+    required int? pid,
+    required List<ProfileFunction>? functions,
+    required List<CpuSample>? samples,
+  }) : super(
+          samplePeriod: samplePeriod,
+          maxStackDepth: maxStackDepth,
+          sampleCount: sampleCount,
+          timeSpan: timeSpan,
+          timeOriginMicros: timeOriginMicros,
+          timeExtentMicros: timeExtentMicros,
+          pid: pid,
+          functions: functions,
+          samples: samples,
+        );
+
+  CachedCpuSamples._fromJson(Map<String, dynamic> json)
+      : userTag = json['userTag']!,
+        truncated = json['truncated'],
+        super(
+          samplePeriod: json['samplePeriod'] ?? -1,
+          maxStackDepth: json['maxStackDepth'] ?? -1,
+          sampleCount: json['sampleCount'] ?? -1,
+          timeSpan: json['timeSpan'] ?? -1,
+          timeOriginMicros: json['timeOriginMicros'] ?? -1,
+          timeExtentMicros: json['timeExtentMicros'] ?? -1,
+          pid: json['pid'] ?? -1,
+          functions: List<ProfileFunction>.from(
+            createServiceObject(json['functions'], const ['ProfileFunction'])
+                    as List? ??
+                [],
+          ),
+          samples: List<CpuSample>.from(
+            createServiceObject(json['samples'], const ['CpuSample'])
+                    as List? ??
+                [],
+          ),
+        );
+
+  @override
+  String get type => 'CachedCpuSamples';
+
+  /// The name of the [UserTag] associated with this cache of [CpuSamples].
+  final String userTag;
+
+  /// Provided if the CPU sample cache has filled and older samples have been
+  /// dropped.
+  final bool? truncated;
+}
+
+/// A collection of [UserTag] names associated with caches of CPU samples.
+class AvailableCachedCpuSamples extends Response {
+  static AvailableCachedCpuSamples? parse(Map<String, dynamic>? json) =>
+      json == null ? null : AvailableCachedCpuSamples._fromJson(json);
+
+  AvailableCachedCpuSamples({
+    required this.cacheNames,
+  });
+
+  AvailableCachedCpuSamples._fromJson(Map<String, dynamic> json)
+      : cacheNames = List<String>.from(json['cacheNames']);
+
+  @override
+  String get type => 'AvailableCachedUserTagCpuSamples';
+
+  /// A [List] of [UserTag] names associated with CPU sample caches.
+  final List<String> cacheNames;
+}
diff --git a/pkg/dds_service_extensions/lib/src/dds_service_extensions_base.dart b/pkg/dds_service_extensions/lib/src/dds_service_extensions_base.dart
new file mode 100644
index 0000000..e8a6f15
--- /dev/null
+++ b/pkg/dds_service_extensions/lib/src/dds_service_extensions_base.dart
@@ -0,0 +1,6 @@
+// TODO: Put public facing types in this file.
+
+/// Checks if you are awesome. Spoiler: you are.
+class Awesome {
+  bool get isAwesome => true;
+}
diff --git a/pkg/dds_service_extensions/pubspec.yaml b/pkg/dds_service_extensions/pubspec.yaml
new file mode 100644
index 0000000..ca19fe2
--- /dev/null
+++ b/pkg/dds_service_extensions/pubspec.yaml
@@ -0,0 +1,18 @@
+name: dds_service_extensions
+description: >-
+  Extension methods for `package:vm_service`, used to make requests a
+  Dart Development Service (DDS) instance.
+
+version: 1.3.0
+
+homepage: https://github.com/dart-lang/sdk/tree/master/pkg/dds_service_extensions
+
+environment:
+  sdk: '>=2.13.0 <3.0.0'
+
+dependencies:
+   async: ^2.4.1
+   vm_service: ^8.1.0
+
+dev_dependencies:
+  lints: ^1.0.0
diff --git a/pkg/dds_service_extensions/test/README b/pkg/dds_service_extensions/test/README
new file mode 100644
index 0000000..77e2983
--- /dev/null
+++ b/pkg/dds_service_extensions/test/README
@@ -0,0 +1 @@
+NOTE: Tests for this package can be found in `package:dds`.
diff --git a/pkg/dev_compiler/lib/src/kernel/asset_file_system.dart b/pkg/dev_compiler/lib/src/kernel/asset_file_system.dart
index a293c28..b2647e0 100644
--- a/pkg/dev_compiler/lib/src/kernel/asset_file_system.dart
+++ b/pkg/dev_compiler/lib/src/kernel/asset_file_system.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart = 2.9
-
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
@@ -43,7 +41,7 @@
   }
 
   void close() {
-    client?.close(force: true);
+    client.close(force: true);
   }
 }
 
diff --git a/pkg/dev_compiler/lib/src/kernel/retry_timeout_client.dart b/pkg/dev_compiler/lib/src/kernel/retry_timeout_client.dart
index ce67906..3adfae3 100644
--- a/pkg/dev_compiler/lib/src/kernel/retry_timeout_client.dart
+++ b/pkg/dev_compiler/lib/src/kernel/retry_timeout_client.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 import 'dart:async';
 import 'dart:io';
 import 'dart:math';
@@ -30,10 +28,10 @@
   final Duration Function(int) _connectionTimeout;
 
   /// The callback that determines when to cancel a request.
-  final Duration Function(int) _reponseTimeout;
+  final Duration Function(int) _responseTimeout;
 
   /// The callback to call to indicate that a request is being retried.
-  final void Function(Uri, HttpClientResponse, int) _onRetry;
+  final void Function(Uri, HttpClientResponse?, int)? _onRetry;
 
   /// Creates a client wrapping [_inner] that retries HTTP requests.
   RetryTimeoutClient(
@@ -44,13 +42,13 @@
     Duration Function(int retryCount) delay = _defaultDelay,
     Duration Function(int retryCount) connectionTimeout = _defaultTimeout,
     Duration Function(int retryCount) responseTimeout = _defaultTimeout,
-    void Function(Uri, HttpClientResponse, int retryCount) onRetry,
+    void Function(Uri, HttpClientResponse?, int retryCount)? onRetry,
   })  : _retries = retries,
         _when = when,
         _whenError = whenError,
         _delay = delay,
         _connectionTimeout = connectionTimeout,
-        _reponseTimeout = responseTimeout,
+        _responseTimeout = responseTimeout,
         _onRetry = onRetry {
     RangeError.checkNotNegative(_retries, 'retries');
   }
@@ -67,13 +65,14 @@
       Uri url, Future<HttpClientRequest> Function(Uri) method) async {
     var i = 0;
     for (;;) {
-      HttpClientResponse response;
+      HttpClientResponse? response;
       try {
         _inner.connectionTimeout = _connectionTimeout(i);
         var request = await method(url).timeout(
-          _reponseTimeout(i),
-          onTimeout: () =>
-              throw TimeoutException('$url, retry:$i', _reponseTimeout(i)),
+          _responseTimeout(i),
+          onTimeout: (() =>
+              throw TimeoutException('$url, retry:$i', _responseTimeout(i))
+                  as FutureOr<HttpClientRequest> Function()),
         );
         response = await request.close();
       } catch (error, stackTrace) {
diff --git a/pkg/dev_compiler/test/expression_compiler/asset_file_system_test.dart b/pkg/dev_compiler/test/expression_compiler/asset_file_system_test.dart
index 77b6904..b0e10c1 100644
--- a/pkg/dev_compiler/test/expression_compiler/asset_file_system_test.dart
+++ b/pkg/dev_compiler/test/expression_compiler/asset_file_system_test.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io' show HttpServer;
@@ -96,8 +94,8 @@
 }
 
 void main() async {
-  HttpServer server;
-  AssetFileSystem fileSystem;
+  late HttpServer server;
+  late AssetFileSystem fileSystem;
   group('AssetFileSystem with a server', () {
     setUpAll(() async {
       var hostname = 'localhost';
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 4dd9122..f405a77 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
@@ -33,26 +33,26 @@
 }
 
 const Version enableAlternativeInvalidationStrategyVersion =
-    const Version(2, 16);
-const Version enableConstFunctionsVersion = const Version(2, 16);
+    const Version(2, 17);
+const Version enableConstFunctionsVersion = const Version(2, 17);
 const Version enableConstantUpdate2018Version = const Version(2, 0);
 const Version enableConstructorTearoffsVersion = const Version(2, 15);
 const Version enableControlFlowCollectionsVersion = const Version(2, 0);
-const Version enableEnhancedEnumsVersion = const Version(2, 16);
+const Version enableEnhancedEnumsVersion = const Version(2, 17);
 const Version enableExtensionMethodsVersion = const Version(2, 6);
-const Version enableExtensionTypesVersion = const Version(2, 16);
+const Version enableExtensionTypesVersion = const Version(2, 17);
 const Version enableGenericMetadataVersion = const Version(2, 14);
-const Version enableMacrosVersion = const Version(2, 16);
-const Version enableNamedArgumentsAnywhereVersion = const Version(2, 16);
+const Version enableMacrosVersion = const Version(2, 17);
+const Version enableNamedArgumentsAnywhereVersion = const Version(2, 17);
 const Version enableNonNullableVersion = const Version(2, 12);
 const Version enableNonfunctionTypeAliasesVersion = const Version(2, 13);
 const Version enableSetLiteralsVersion = const Version(2, 0);
 const Version enableSpreadCollectionsVersion = const Version(2, 0);
-const Version enableSuperParametersVersion = const Version(2, 16);
-const Version enableTestExperimentVersion = const Version(2, 16);
+const Version enableSuperParametersVersion = const Version(2, 17);
+const Version enableTestExperimentVersion = const Version(2, 17);
 const Version enableTripleShiftVersion = const Version(2, 14);
-const Version enableValueClassVersion = const Version(2, 16);
-const Version enableVarianceVersion = const Version(2, 16);
+const Version enableValueClassVersion = const Version(2, 17);
+const Version enableVarianceVersion = const Version(2, 17);
 
 ExperimentalFlag? parseExperimentalFlag(String flag) {
   switch (flag) {
@@ -147,49 +147,49 @@
 };
 
 const Map<ExperimentalFlag, Version> experimentEnabledVersion = {
-  ExperimentalFlag.alternativeInvalidationStrategy: const Version(2, 16),
-  ExperimentalFlag.constFunctions: const Version(2, 16),
+  ExperimentalFlag.alternativeInvalidationStrategy: const Version(2, 17),
+  ExperimentalFlag.constFunctions: const Version(2, 17),
   ExperimentalFlag.constantUpdate2018: const Version(2, 0),
   ExperimentalFlag.constructorTearoffs: const Version(2, 15),
   ExperimentalFlag.controlFlowCollections: const Version(2, 0),
-  ExperimentalFlag.enhancedEnums: const Version(2, 16),
+  ExperimentalFlag.enhancedEnums: const Version(2, 17),
   ExperimentalFlag.extensionMethods: const Version(2, 6),
-  ExperimentalFlag.extensionTypes: const Version(2, 16),
+  ExperimentalFlag.extensionTypes: const Version(2, 17),
   ExperimentalFlag.genericMetadata: const Version(2, 14),
-  ExperimentalFlag.macros: const Version(2, 16),
-  ExperimentalFlag.namedArgumentsAnywhere: const Version(2, 16),
+  ExperimentalFlag.macros: const Version(2, 17),
+  ExperimentalFlag.namedArgumentsAnywhere: const Version(2, 17),
   ExperimentalFlag.nonNullable: const Version(2, 12),
   ExperimentalFlag.nonfunctionTypeAliases: const Version(2, 13),
   ExperimentalFlag.setLiterals: const Version(2, 0),
   ExperimentalFlag.spreadCollections: const Version(2, 0),
-  ExperimentalFlag.superParameters: const Version(2, 16),
-  ExperimentalFlag.testExperiment: const Version(2, 16),
+  ExperimentalFlag.superParameters: const Version(2, 17),
+  ExperimentalFlag.testExperiment: const Version(2, 17),
   ExperimentalFlag.tripleShift: const Version(2, 14),
-  ExperimentalFlag.valueClass: const Version(2, 16),
-  ExperimentalFlag.variance: const Version(2, 16),
+  ExperimentalFlag.valueClass: const Version(2, 17),
+  ExperimentalFlag.variance: const Version(2, 17),
 };
 
 const Map<ExperimentalFlag, Version> experimentReleasedVersion = {
-  ExperimentalFlag.alternativeInvalidationStrategy: const Version(2, 16),
-  ExperimentalFlag.constFunctions: const Version(2, 16),
+  ExperimentalFlag.alternativeInvalidationStrategy: const Version(2, 17),
+  ExperimentalFlag.constFunctions: const Version(2, 17),
   ExperimentalFlag.constantUpdate2018: const Version(2, 0),
   ExperimentalFlag.constructorTearoffs: const Version(2, 15),
   ExperimentalFlag.controlFlowCollections: const Version(2, 0),
-  ExperimentalFlag.enhancedEnums: const Version(2, 16),
+  ExperimentalFlag.enhancedEnums: const Version(2, 17),
   ExperimentalFlag.extensionMethods: const Version(2, 6),
-  ExperimentalFlag.extensionTypes: const Version(2, 16),
+  ExperimentalFlag.extensionTypes: const Version(2, 17),
   ExperimentalFlag.genericMetadata: const Version(2, 14),
-  ExperimentalFlag.macros: const Version(2, 16),
-  ExperimentalFlag.namedArgumentsAnywhere: const Version(2, 16),
+  ExperimentalFlag.macros: const Version(2, 17),
+  ExperimentalFlag.namedArgumentsAnywhere: const Version(2, 17),
   ExperimentalFlag.nonNullable: const Version(2, 10),
   ExperimentalFlag.nonfunctionTypeAliases: const Version(2, 13),
   ExperimentalFlag.setLiterals: const Version(2, 0),
   ExperimentalFlag.spreadCollections: const Version(2, 0),
-  ExperimentalFlag.superParameters: const Version(2, 16),
-  ExperimentalFlag.testExperiment: const Version(2, 16),
+  ExperimentalFlag.superParameters: const Version(2, 17),
+  ExperimentalFlag.testExperiment: const Version(2, 17),
   ExperimentalFlag.tripleShift: const Version(2, 14),
-  ExperimentalFlag.valueClass: const Version(2, 16),
-  ExperimentalFlag.variance: const Version(2, 16),
+  ExperimentalFlag.valueClass: const Version(2, 17),
+  ExperimentalFlag.variance: const Version(2, 17),
 };
 
 const AllowedExperimentalFlags defaultAllowedExperimentalFlags =
diff --git a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
index ed6468b..887ed4c 100644
--- a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
@@ -5347,10 +5347,6 @@
       }
     }
     if (type is ClassBuilder) {
-      if (type is SourceEnumBuilder) {
-        return buildProblem(fasta.messageEnumInstantiation,
-            nameToken.charOffset, nameToken.length);
-      }
       MemberBuilder? b =
           type.findConstructorOrFactory(name, charOffset, uri, libraryBuilder);
       Member? target;
@@ -5372,6 +5368,13 @@
       } else {
         target = b.member;
       }
+      if (type is SourceEnumBuilder &&
+          !(libraryBuilder.enableEnhancedEnumsInLibrary &&
+              target is Procedure &&
+              target.kind == ProcedureKind.Factory)) {
+        return buildProblem(fasta.messageEnumInstantiation,
+            nameToken.charOffset, nameToken.length);
+      }
       if (target is Constructor ||
           (target is Procedure && target.kind == ProcedureKind.Factory)) {
         Expression invocation;
diff --git a/pkg/front_end/lib/src/fasta/kernel/hierarchy/hierarchy_node.dart b/pkg/front_end/lib/src/fasta/kernel/hierarchy/hierarchy_node.dart
index a5e89b9..30bd373 100644
--- a/pkg/front_end/lib/src/fasta/kernel/hierarchy/hierarchy_node.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/hierarchy/hierarchy_node.dart
@@ -48,9 +48,7 @@
     }
 
     List<Supertype> superclasses;
-
-    List<Supertype> interfaces;
-
+    List<Supertype> interfacesList;
     int maxInheritancePath;
 
     List<TypeBuilder>? directInterfaceBuilders;
@@ -62,7 +60,7 @@
     if (supernode == null) {
       // This should be Object.
       superclasses = new List<Supertype>.filled(0, dummySupertype);
-      interfaces = new List<Supertype>.filled(0, dummySupertype);
+      interfacesList = new List<Supertype>.filled(0, dummySupertype);
       maxInheritancePath = 0;
     } else {
       maxInheritancePath = supernode.maxInheritancePath + 1;
@@ -107,7 +105,7 @@
       }
 
       if (directInterfaceBuilders != null) {
-        interfaces = <Supertype>[];
+        Map<Class, Supertype> interfaces = {};
         // ignore: unnecessary_null_comparison
         if (superclassInterfaces != null) {
           for (int i = 0; i < superclassInterfaces.length; i++) {
@@ -145,16 +143,18 @@
             }
           }
         }
+        interfacesList = interfaces.values.toList();
         // ignore: unnecessary_null_comparison
       } else if (superclassInterfaces != null &&
           !classBuilder.library.isNonNullableByDefault &&
           supernode.classBuilder.library.isNonNullableByDefault) {
-        interfaces = <Supertype>[];
+        Map<Class, Supertype> interfaces = {};
         for (int i = 0; i < superclassInterfaces.length; i++) {
           addInterface(interfaces, superclasses, superclassInterfaces[i]);
         }
+        interfacesList = interfaces.values.toList();
       } else {
-        interfaces = superclassInterfaces;
+        interfacesList = superclassInterfaces;
       }
     }
 
@@ -162,30 +162,19 @@
       recordSupertype(superclass);
     }
     // ignore: unnecessary_null_comparison
-    if (interfaces != null) {
-      for (Supertype superinterface in interfaces) {
+    if (interfacesList != null) {
+      for (Supertype superinterface in interfacesList) {
         recordSupertype(superinterface);
       }
     }
 
-    /*ClassHierarchyMemberNode memberNode =
-    buildMemberNode(supernode, directInterfaceBuilders);*/
-
     return new ClassHierarchyNode(
-      classBuilder,
-      supernode,
-      directInterfaceBuilders,
-      /*classMemberMap,
-        classSetterMap,
-        interfaceMemberMap,
-        interfaceSetterMap,*/
-      superclasses,
-      interfaces,
-      maxInheritancePath,
-      /*hasNoSuchMethod,
-        dataForTesting,*/
-      /*memberNode*/
-    );
+        classBuilder,
+        supernode,
+        directInterfaceBuilders,
+        superclasses,
+        interfacesList,
+        maxInheritancePath);
   }
 
   Supertype recordSupertype(Supertype supertype) {
@@ -242,8 +231,8 @@
     return result ?? supertypes;
   }
 
-  void addInterface(List<Supertype> interfaces, List<Supertype> superclasses,
-      Supertype type) {
+  void addInterface(Map<Class, Supertype> interfaces,
+      List<Supertype> superclasses, Supertype type) {
     // ignore: unnecessary_null_comparison
     if (type == null) return null;
     if (!classBuilder.library.isNonNullableByDefault) {
@@ -273,31 +262,26 @@
       }
       return;
     } else {
-      for (int i = 0; i < interfaces.length; i++) {
-        // This is a quadratic algorithm, but normally, the number of
-        // interfaces is really small.
-        Supertype? interface = interfaces[i];
-        if (interface.classNode == type.classNode) {
-          // This is a potential conflict.
-          if (classBuilder.library.isNonNullableByDefault) {
-            interface = nnbdTopMergeSupertype(
-                hierarchy.coreTypes,
-                normSupertype(hierarchy.coreTypes, interface),
-                normSupertype(hierarchy.coreTypes, type));
-            if (interface == null) {
-              // This is a conflict.
-              // TODO(johnniwinther): Report errors here instead of through
-              // the computation of the [ClassHierarchy].
-              interface = interfaces[i];
-            } else {
-              interfaces[i] = interface;
-            }
+      Supertype? interface = interfaces[type.classNode];
+      if (interface != null) {
+        // This is a potential conflict.
+        if (classBuilder.library.isNonNullableByDefault) {
+          interface = nnbdTopMergeSupertype(
+              hierarchy.coreTypes,
+              normSupertype(hierarchy.coreTypes, interface),
+              normSupertype(hierarchy.coreTypes, type));
+          if (interface == null) {
+            // This is a conflict.
+            // TODO(johnniwinther): Report errors here instead of through
+            // the computation of the [ClassHierarchy].
+          } else {
+            interfaces[type.classNode] = interface;
           }
-          return;
         }
+        return;
       }
     }
-    interfaces.add(type);
+    interfaces[type.classNode] = type;
   }
 
   void inferMixinApplication() {
@@ -349,27 +333,6 @@
 
   final List<TypeBuilder>? directInterfaceBuilders;
 
-  /*/// All the members of this class including [classMembers] of its
-  /// superclasses. The members are sorted by [compareDeclarations].
-  final Map<Name, ClassMember> classMemberMap;
-
-  /// Similar to [classMembers] but for setters.
-  final Map<Name, ClassMember> classSetterMap;
-
-  /// All the interface members of this class including [interfaceMembers] of
-  /// its supertypes. The members are sorted by [compareDeclarations].
-  ///
-  /// In addition to the members of [classMembers] this also contains members
-  /// from interfaces.
-  ///
-  /// This may be null, in which case [classMembers] is the interface members.
-  final Map<Name, ClassMember>? interfaceMemberMap;
-
-  /// Similar to [interfaceMembers] but for setters.
-  ///
-  /// This may be null, in which case [classSetters] is the interface setters.
-  final Map<Name, ClassMember>? interfaceSetterMap;*/
-
   /// All superclasses of [classBuilder] excluding itself. The classes are
   /// sorted by depth from the root (Object) in ascending order.
   final List<Supertype> superclasses;
@@ -383,27 +346,13 @@
 
   int get depth => superclasses.length;
 
-  /*final bool hasNoSuchMethod;
-
-  final ClassHierarchyNodeDataForTesting? dataForTesting;*/
-
-  //final ClassHierarchyMemberNode memberNode;
-
   ClassHierarchyNode(
-    this.classBuilder,
-    this.supernode,
-    this.directInterfaceBuilders,
-    /*this.classMemberMap,
-      this.classSetterMap,
-      this.interfaceMemberMap,
-      this.interfaceSetterMap,*/
-    this.superclasses,
-    this.interfaces,
-    this.maxInheritancePath,
-    /*this.hasNoSuchMethod,
-      this.dataForTesting,*/
-    /*this.memberNode*/
-  );
+      this.classBuilder,
+      this.supernode,
+      this.directInterfaceBuilders,
+      this.superclasses,
+      this.interfaces,
+      this.maxInheritancePath);
 
   /// Returns a list of all supertypes of [classBuilder], including this node.
   List<ClassHierarchyNode> computeAllSuperNodes(
diff --git a/pkg/front_end/lib/src/fasta/source/diet_listener.dart b/pkg/front_end/lib/src/fasta/source/diet_listener.dart
index f24e48b..77c43b7 100644
--- a/pkg/front_end/lib/src/fasta/source/diet_listener.dart
+++ b/pkg/front_end/lib/src/fasta/source/diet_listener.dart
@@ -987,37 +987,15 @@
   @override
   void endEnumConstructor(Token? getOrSet, Token beginToken, Token beginParam,
       Token? beginInitializers, Token endToken) {
-    // TODO(chloestefantsova): Call endClassConstructor instead.
-    debugEvent("EnumConstructor");
-    pop(); // bodyToken
-    pop(); // name
-    pop(); // metadata
-    checkEmpty(beginToken.charOffset);
-    // Skip the declaration. An error as already been produced by the parser.
-  }
-
-  @override
-  void endEnumFactoryMethod(
-      Token beginToken, Token factoryKeyword, Token endToken) {
-    // TODO(chloestefantsova): Call endClassFactoryMethod instead.
-    debugEvent("EnumFactoryMethod");
-    pop(); // bodyToken
-    pop(); // name
-    pop(); // metadata
-    checkEmpty(beginToken.charOffset);
-    // Skip the declaration. An error as already been produced by the parser.
+    _endClassMethod(
+        getOrSet, beginToken, beginParam, beginInitializers, endToken, true);
   }
 
   @override
   void endEnumMethod(Token? getOrSet, Token beginToken, Token beginParam,
       Token? beginInitializers, Token endToken) {
-    // TODO(chloestefantsova): Call endClassMethod instead.
-    debugEvent("EnumMethod");
-    pop(); // bodyToken
-    pop(); // name
-    pop(); // metadata
-    checkEmpty(beginToken.charOffset);
-    // Skip the declaration. An error as already been produced by the parser.
+    _endClassMethod(
+        getOrSet, beginToken, beginParam, beginInitializers, endToken, false);
   }
 
   @override
@@ -1031,12 +1009,8 @@
       int count,
       Token beginToken,
       Token endToken) {
-    // TODO(chloestefantsova): Call endClassFields instead.
-    debugEvent("EnumFields");
-    const FixedNullableList<String>().pop(stack, count); // names
-    pop(); // metadata
-    checkEmpty(beginToken.charOffset);
-    // Skip the declaration. An error as already been produced by the parser.
+    debugEvent("Fields");
+    buildFields(count, beginToken, false);
   }
 
   @override
diff --git a/pkg/front_end/lib/src/fasta/source/outline_builder.dart b/pkg/front_end/lib/src/fasta/source/outline_builder.dart
index 2bd2dab..820c2d5 100644
--- a/pkg/front_end/lib/src/fasta/source/outline_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/outline_builder.dart
@@ -1764,6 +1764,7 @@
         case _MethodKind.classMethod:
         case _MethodKind.mixinMethod:
         case _MethodKind.extensionMethod:
+        case _MethodKind.enumMethod:
           break;
       }
       bool isStatic = (modifiers & staticMask) != 0;
@@ -3029,71 +3030,7 @@
   @override
   void endEnumFactoryMethod(
       Token beginToken, Token factoryKeyword, Token endToken) {
-    // TODO(cstefantsova): Call endClassFactoryMethod instead.
     debugEvent("EnumFactoryMethod");
-    MethodBody bodyKind = pop() as MethodBody;
-    if (bodyKind == MethodBody.RedirectingFactoryBody) {
-      pop(); // reference
-    }
-    pop(); // async marker
-    pop(); // formals
-    popCharOffset(); // formals char offset
-    pop(); // type variables
-    popCharOffset(); // char offset
-    pop(); // name
-    pop(); // modifiers
-    pop(); // metadata
-    popDeclarationContext();
-    // TODO(cstefantsova): Use actual type parameters.
-    libraryBuilder
-        .endNestedDeclaration(
-            TypeParameterScopeKind.factoryMethod, "#factory_method")
-        .resolveNamedTypes([], libraryBuilder);
-    // Skip the declaration. An error as already been produced by the parser.
-
-    if (libraryBuilder.enableEnhancedEnumsInLibrary) {
-      addProblem(messageEnumDeclaresFactory, beginToken.charOffset, -1);
-    } else {
-      addProblem(
-          templateExperimentNotEnabled.withArguments('enhanced-enums',
-              libraryBuilder.enableEnhancedEnumsVersionInLibrary.toText()),
-          beginToken.charOffset,
-          -1);
-    }
-  }
-
-  @override
-  void endEnumMethod(Token? getOrSet, Token beginToken, Token beginParam,
-      Token? beginInitializers, Token endToken) {
-    // TODO(cstefantsova): Call endClassMethod instead.
-    debugEvent("EnumMethod");
-    MethodBody bodyKind = pop() as MethodBody;
-    if (bodyKind == MethodBody.RedirectingFactoryBody) {
-      pop(); // reference
-    }
-    pop(); // async marker
-    pop(); // formals
-    popCharOffset(); // formals char offset
-    pop(); // type variables
-    popCharOffset(); // char offset
-    pop(); // name
-    pop(); // return type
-    int modifiers = Modifier.toMask(pop() as List<Modifier>?);
-    popCharOffset(); // final or const offset
-    pop(); // metadata
-    popDeclarationContext();
-    TypeParameterScopeKind scopeKind;
-    if ((modifiers & staticMask) != 0) {
-      scopeKind = TypeParameterScopeKind.staticMethod;
-    } else {
-      scopeKind = TypeParameterScopeKind.instanceMethod;
-    }
-    // TODO(cstefantsova): Use actual type parameters.
-    libraryBuilder
-        .endNestedDeclaration(scopeKind, "#method")
-        .resolveNamedTypes([], libraryBuilder);
-    // Skip the declaration. An error as already been produced by the parser.
-
     if (!libraryBuilder.enableEnhancedEnumsInLibrary) {
       addProblem(
           templateExperimentNotEnabled.withArguments('enhanced-enums',
@@ -3101,6 +3038,23 @@
           beginToken.charOffset,
           -1);
     }
+
+    _endFactoryMethod(beginToken, factoryKeyword, endToken);
+  }
+
+  @override
+  void endEnumMethod(Token? getOrSet, Token beginToken, Token beginParam,
+      Token? beginInitializers, Token endToken) {
+    if (!libraryBuilder.enableEnhancedEnumsInLibrary) {
+      addProblem(
+          templateExperimentNotEnabled.withArguments('enhanced-enums',
+              libraryBuilder.enableEnhancedEnumsVersionInLibrary.toText()),
+          beginToken.charOffset,
+          -1);
+    }
+
+    _endClassMethod(getOrSet, beginToken, beginParam, beginInitializers,
+        endToken, _MethodKind.enumMethod);
   }
 
   @override
@@ -3134,10 +3088,10 @@
               libraryBuilder.enableEnhancedEnumsVersionInLibrary.toText()),
           beginToken.charOffset,
           -1);
-    } else {
-      _endClassMethod(getOrSet, beginToken, beginParam, beginInitializers,
-          endToken, _MethodKind.enumConstructor);
     }
+
+    _endClassMethod(getOrSet, beginToken, beginParam, beginInitializers,
+        endToken, _MethodKind.enumConstructor);
   }
 
   @override
@@ -3322,4 +3276,5 @@
   extensionConstructor,
   extensionMethod,
   enumConstructor,
+  enumMethod,
 }
diff --git a/pkg/front_end/lib/src/fasta/source/source_enum_builder.dart b/pkg/front_end/lib/src/fasta/source/source_enum_builder.dart
index 9dc50e7..2f84424 100644
--- a/pkg/front_end/lib/src/fasta/source/source_enum_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_enum_builder.dart
@@ -409,7 +409,7 @@
         new Scope(
             local: members,
             setters: setters,
-            parent: parent.scope,
+            parent: scope.parent,
             debugName: "enum $name",
             isModifiable: false),
         constructorScope..local.addAll(constructors),
@@ -555,11 +555,11 @@
 
           String constructorName =
               enumConstantInfo.constructorReferenceBuilder?.suffix ?? "";
-          SourceConstructorBuilder? constructorBuilder =
-              constructorScopeBuilder[constructorName]
-                  as SourceConstructorBuilder?;
+          MemberBuilder? constructorBuilder =
+              constructorScopeBuilder[constructorName];
 
-          if (constructorBuilder == null) {
+          if (constructorBuilder == null ||
+              constructorBuilder is! SourceConstructorBuilder) {
             // TODO(cstefantsova): Report an error.
           } else {
             Arguments arguments;
@@ -629,17 +629,11 @@
             interfaceTargetReference: nameField.getterReference,
             resultType: nameField.getterType),
       ]));
-    } else {}
+    }
 
     super.buildOutlineExpressions(library, classHierarchy,
         delayedActionPerformers, synthesizedFunctionNodes);
   }
-
-  @override
-  MemberBuilder? findConstructorOrFactory(
-      String name, int charOffset, Uri uri, LibraryBuilder library) {
-    return null;
-  }
 }
 
 class EnumConstantInfo {
diff --git a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
index 9aa1463..01f02a8 100644
--- a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
@@ -2830,7 +2830,7 @@
         new Scope(
             local: members,
             setters: setters,
-            parent: scope.withTypeVariables(<TypeVariableBuilder>[]),
+            parent: scope.withTypeVariables(typeVariables),
             debugName: "enum $name",
             isModifiable: false),
         new ConstructorScope(name, constructors));
diff --git a/pkg/front_end/messages.status b/pkg/front_end/messages.status
index 0fed875..0c1fb2b 100644
--- a/pkg/front_end/messages.status
+++ b/pkg/front_end/messages.status
@@ -213,6 +213,8 @@
 DuplicatedParameterName/example: Fail
 Encoding/analyzerCode: Fail
 EnumConstantSameNameAsEnclosing/example: Fail
+EnumDeclaresConstFactory/analyzerCode: Fail
+EnumDeclaresConstFactory/example: Fail
 EnumDeclaresFactory/analyzerCode: Fail
 EnumDeclaresFactory/example: Fail
 EnumInstantiation/example: Fail
diff --git a/pkg/front_end/messages.yaml b/pkg/front_end/messages.yaml
index 9819804..77e7660 100644
--- a/pkg/front_end/messages.yaml
+++ b/pkg/front_end/messages.yaml
@@ -5455,8 +5455,8 @@
   script: |
     method(dynamic d) => d.new;
 
-EnumDeclaresFactory:
-  problemMessage: "Enums can't declare factory constructors."
+EnumDeclaresConstFactory:
+  problemMessage: "Enums can't declare const factory constructors."
   correctionMessage: "Try removing the factory constructor declaration."
 
 PositionalSuperParametersAndArguments:
diff --git a/pkg/front_end/test/macros/macro_test.dart b/pkg/front_end/test/macros/macro_test.dart
index 7a4dee8..2ceca95 100644
--- a/pkg/front_end/test/macros/macro_test.dart
+++ b/pkg/front_end/test/macros/macro_test.dart
@@ -5,6 +5,7 @@
 import 'dart:io' show Directory, Platform;
 import 'package:_fe_analyzer_shared/src/macros/api.dart';
 import 'package:_fe_analyzer_shared/src/macros/executor.dart';
+import 'package:_fe_analyzer_shared/src/macros/executor_shared/serialization.dart';
 import 'package:_fe_analyzer_shared/src/testing/id.dart' show ActualData, Id;
 import 'package:_fe_analyzer_shared/src/testing/id_testing.dart';
 import 'package:_fe_analyzer_shared/src/testing/features.dart';
@@ -292,7 +293,12 @@
   }
 
   @override
-  Future<MacroClassIdentifier> loadMacro(Uri library, String name) async {
+  Future<MacroClassIdentifier> loadMacro(Uri library, String name,
+      {Uri? precompiledKernelUri}) async {
+    if (precompiledKernelUri != null) {
+      throw new UnsupportedError(
+          'Precompiled kernel not supported for this implementation.');
+    }
     _MacroClassIdentifier id = new _MacroClassIdentifier(library, name);
     macroClasses.add(id);
     return id;
@@ -320,6 +326,9 @@
 
   @override
   String toString() => 'MacroClassIdentifier($uri,$className)';
+
+  @override
+  void serialize(Serializer serializer) => throw UnimplementedError();
 }
 
 class _MacroInstanceIdentifier implements MacroInstanceIdentifier {
@@ -330,4 +339,7 @@
   _MacroInstanceIdentifier(this.macroClass, this.constructor, this.arguments);
 
   String toText() => '${macroClass.toText()}/${constructor}()';
+
+  @override
+  void serialize(Serializer serializer) => throw UnimplementedError();
 }
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index 613e0b7..8b9b65b4 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -141,6 +141,7 @@
 bof
 bom
 bones
+bootstrap
 bother
 boundness
 boxed
@@ -326,6 +327,7 @@
 degrades
 degree
 del
+delegated
 delimit
 delimiting
 demands
@@ -420,6 +422,7 @@
 engineered
 enhanced
 enters
+entrypoint
 entrypointish
 enumerates
 env
@@ -436,6 +439,7 @@
 eval
 execute
 executor
+executors
 exhausted
 existence
 existentially
@@ -603,6 +607,7 @@
 impl
 impl+
 implementers
+impls
 imply
 implying
 importantly
@@ -614,6 +619,7 @@
 inconsistency
 increased
 incremented
+incrementing
 independently
 indexer
 indexing
@@ -668,6 +674,7 @@
 is64
 isolate
 isolated
+isolates
 issuecomment
 issuing
 iterables
@@ -840,6 +847,7 @@
 newest
 nextnext
 ni
+nil
 nine
 nj
 nk
@@ -969,6 +977,7 @@
 pre
 prebuild
 prebuilt
+precompiled
 preexisted
 preexisting
 premark
@@ -1226,6 +1235,7 @@
 spaced
 sparse
 spawn
+spawned
 spawns
 spec
 spec'ed
@@ -1483,6 +1493,7 @@
 vegorov
 verbosity
 versa
+versus
 viable
 vice
 video
diff --git a/pkg/front_end/test/spell_checking_list_tests.txt b/pkg/front_end/test/spell_checking_list_tests.txt
index d9f5fdf..97ef414 100644
--- a/pkg/front_end/test/spell_checking_list_tests.txt
+++ b/pkg/front_end/test/spell_checking_list_tests.txt
@@ -1060,7 +1060,6 @@
 xxxxxxxxxxxx
 xyz
 y's
-yaml2json
 year
 yxxx
 yy
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48084.dart b/pkg/front_end/testcases/enhanced_enums/issue48084.dart
new file mode 100644
index 0000000..433bea6
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/issue48084.dart
@@ -0,0 +1,26 @@
+// Copyright (c) 2021, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+enum E {
+  one("foo"),
+  two("bar");
+
+  final String field;
+
+  const E(this.field);
+
+  @override
+  String toString() => field;
+}
+
+expectEquals(a, b) {
+  if (a != b) {
+    throw "Expected '$a' and '$b' to be equal.";
+  }
+}
+
+main() {
+  expectEquals("${E.one}", "foo");
+  expectEquals("${E.two}", "bar");
+}
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48084.dart.strong.expect b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.strong.expect
new file mode 100644
index 0000000..1da7d5a
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.strong.expect
@@ -0,0 +1,45 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = #C9;
+  static const field self::E one = #C4;
+  static const field self::E two = #C8;
+  final field core::String field;
+  const constructor •(core::int index, core::String name, core::String field) → self::E
+    : self::E::field = field, super core::_Enum::•(index, name)
+    ;
+  @#C10
+  method toString() → core::String
+    return this.{self::E::field}{core::String};
+}
+static method expectEquals(dynamic a, dynamic b) → dynamic {
+  if(!(a =={core::Object::==}{(core::Object) → core::bool} b)) {
+    throw "Expected '${a}' and '${b}' to be equal.";
+  }
+}
+static method main() → dynamic {
+  self::expectEquals("${#C4}", "foo");
+  self::expectEquals("${#C8}", "bar");
+}
+
+constants  {
+  #C1 = "foo"
+  #C2 = 0
+  #C3 = "one"
+  #C4 = self::E {field:#C1, index:#C2, _name:#C3}
+  #C5 = "bar"
+  #C6 = 1
+  #C7 = "two"
+  #C8 = self::E {field:#C5, index:#C6, _name:#C7}
+  #C9 = <self::E>[#C4, #C8]
+  #C10 = core::_Override {}
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///issue48084.dart:
+- E. (from org-dartlang-testcase:///issue48084.dart:11:9)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48084.dart.strong.transformed.expect b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.strong.transformed.expect
new file mode 100644
index 0000000..1da7d5a
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.strong.transformed.expect
@@ -0,0 +1,45 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = #C9;
+  static const field self::E one = #C4;
+  static const field self::E two = #C8;
+  final field core::String field;
+  const constructor •(core::int index, core::String name, core::String field) → self::E
+    : self::E::field = field, super core::_Enum::•(index, name)
+    ;
+  @#C10
+  method toString() → core::String
+    return this.{self::E::field}{core::String};
+}
+static method expectEquals(dynamic a, dynamic b) → dynamic {
+  if(!(a =={core::Object::==}{(core::Object) → core::bool} b)) {
+    throw "Expected '${a}' and '${b}' to be equal.";
+  }
+}
+static method main() → dynamic {
+  self::expectEquals("${#C4}", "foo");
+  self::expectEquals("${#C8}", "bar");
+}
+
+constants  {
+  #C1 = "foo"
+  #C2 = 0
+  #C3 = "one"
+  #C4 = self::E {field:#C1, index:#C2, _name:#C3}
+  #C5 = "bar"
+  #C6 = 1
+  #C7 = "two"
+  #C8 = self::E {field:#C5, index:#C6, _name:#C7}
+  #C9 = <self::E>[#C4, #C8]
+  #C10 = core::_Override {}
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///issue48084.dart:
+- E. (from org-dartlang-testcase:///issue48084.dart:11:9)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48084.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.textual_outline.expect
new file mode 100644
index 0000000..57d7640
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.textual_outline.expect
@@ -0,0 +1,3 @@
+enum E { one("foo"), two("bar"); final String field; const E(this.field); @override String toString() => field; }
+expectEquals(a, b) {}
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48084.dart.weak.expect b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.weak.expect
new file mode 100644
index 0000000..32c1780
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.weak.expect
@@ -0,0 +1,45 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = #C9;
+  static const field self::E one = #C4;
+  static const field self::E two = #C8;
+  final field core::String field;
+  const constructor •(core::int index, core::String name, core::String field) → self::E
+    : self::E::field = field, super core::_Enum::•(index, name)
+    ;
+  @#C10
+  method toString() → core::String
+    return this.{self::E::field}{core::String};
+}
+static method expectEquals(dynamic a, dynamic b) → dynamic {
+  if(!(a =={core::Object::==}{(core::Object) → core::bool} b)) {
+    throw "Expected '${a}' and '${b}' to be equal.";
+  }
+}
+static method main() → dynamic {
+  self::expectEquals("${#C4}", "foo");
+  self::expectEquals("${#C8}", "bar");
+}
+
+constants  {
+  #C1 = "foo"
+  #C2 = 0
+  #C3 = "one"
+  #C4 = self::E {field:#C1, index:#C2, _name:#C3}
+  #C5 = "bar"
+  #C6 = 1
+  #C7 = "two"
+  #C8 = self::E {field:#C5, index:#C6, _name:#C7}
+  #C9 = <self::E*>[#C4, #C8]
+  #C10 = core::_Override {}
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///issue48084.dart:
+- E. (from org-dartlang-testcase:///issue48084.dart:11:9)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48084.dart.weak.modular.expect b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.weak.modular.expect
new file mode 100644
index 0000000..32c1780
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.weak.modular.expect
@@ -0,0 +1,45 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = #C9;
+  static const field self::E one = #C4;
+  static const field self::E two = #C8;
+  final field core::String field;
+  const constructor •(core::int index, core::String name, core::String field) → self::E
+    : self::E::field = field, super core::_Enum::•(index, name)
+    ;
+  @#C10
+  method toString() → core::String
+    return this.{self::E::field}{core::String};
+}
+static method expectEquals(dynamic a, dynamic b) → dynamic {
+  if(!(a =={core::Object::==}{(core::Object) → core::bool} b)) {
+    throw "Expected '${a}' and '${b}' to be equal.";
+  }
+}
+static method main() → dynamic {
+  self::expectEquals("${#C4}", "foo");
+  self::expectEquals("${#C8}", "bar");
+}
+
+constants  {
+  #C1 = "foo"
+  #C2 = 0
+  #C3 = "one"
+  #C4 = self::E {field:#C1, index:#C2, _name:#C3}
+  #C5 = "bar"
+  #C6 = 1
+  #C7 = "two"
+  #C8 = self::E {field:#C5, index:#C6, _name:#C7}
+  #C9 = <self::E*>[#C4, #C8]
+  #C10 = core::_Override {}
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///issue48084.dart:
+- E. (from org-dartlang-testcase:///issue48084.dart:11:9)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48084.dart.weak.outline.expect b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.weak.outline.expect
new file mode 100644
index 0000000..1419d47
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.weak.outline.expect
@@ -0,0 +1,28 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = const <self::E>[self::E::one, self::E::two];
+  static const field self::E one = const self::E::•(0, "one", "foo");
+  static const field self::E two = const self::E::•(1, "two", "bar");
+  final field core::String field;
+  const constructor •(core::int index, core::String name, core::String field) → self::E
+    : self::E::field = field, super core::_Enum::•(index, name)
+    ;
+  @core::override
+  method toString() → core::String
+    return "E.${this.{core::_Enum::_name}{core::String}}";
+}
+static method expectEquals(dynamic a, dynamic b) → dynamic
+  ;
+static method main() → dynamic
+  ;
+
+
+Extra constant evaluation status:
+Evaluated: StaticGet @ org-dartlang-testcase:///issue48084.dart:13:4 -> InstanceConstant(const _Override{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///issue48084.dart:5:6 -> ListConstant(const <E*>[const E{E.field: "foo", _Enum.index: 0, _Enum._name: "one"}, const E{E.field: "bar", _Enum.index: 1, _Enum._name: "two"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///issue48084.dart:6:3 -> InstanceConstant(const E{E.field: "foo", _Enum.index: 0, _Enum._name: "one"})
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///issue48084.dart:7:3 -> InstanceConstant(const E{E.field: "bar", _Enum.index: 1, _Enum._name: "two"})
+Extra constant evaluation: evaluated: 10, effectively constant: 4
diff --git a/pkg/front_end/testcases/enhanced_enums/issue48084.dart.weak.transformed.expect b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.weak.transformed.expect
new file mode 100644
index 0000000..32c1780
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/issue48084.dart.weak.transformed.expect
@@ -0,0 +1,45 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = #C9;
+  static const field self::E one = #C4;
+  static const field self::E two = #C8;
+  final field core::String field;
+  const constructor •(core::int index, core::String name, core::String field) → self::E
+    : self::E::field = field, super core::_Enum::•(index, name)
+    ;
+  @#C10
+  method toString() → core::String
+    return this.{self::E::field}{core::String};
+}
+static method expectEquals(dynamic a, dynamic b) → dynamic {
+  if(!(a =={core::Object::==}{(core::Object) → core::bool} b)) {
+    throw "Expected '${a}' and '${b}' to be equal.";
+  }
+}
+static method main() → dynamic {
+  self::expectEquals("${#C4}", "foo");
+  self::expectEquals("${#C8}", "bar");
+}
+
+constants  {
+  #C1 = "foo"
+  #C2 = 0
+  #C3 = "one"
+  #C4 = self::E {field:#C1, index:#C2, _name:#C3}
+  #C5 = "bar"
+  #C6 = 1
+  #C7 = "two"
+  #C8 = self::E {field:#C5, index:#C6, _name:#C7}
+  #C9 = <self::E*>[#C4, #C8]
+  #C10 = core::_Override {}
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///issue48084.dart:
+- E. (from org-dartlang-testcase:///issue48084.dart:11:9)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
diff --git a/pkg/front_end/testcases/enhanced_enums/members.dart b/pkg/front_end/testcases/enhanced_enums/members.dart
new file mode 100644
index 0000000..a4fab29
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/members.dart
@@ -0,0 +1,41 @@
+// Copyright (c) 2021, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+enum E {
+  one(1),
+  two(2);
+
+  final int foo;
+  final int bar = 42;
+
+  static E staticFoo = new E.f();
+
+  const E(this.foo);
+
+  factory E.f() => E.one;
+
+  int method(int value) => value + 10;
+
+  String staticMethod(double d, bool b) => "$d$b";
+}
+
+enum E2<X> {
+  one<num>(1),
+  two("2");
+
+  final X foo;
+  final X? bar = null;
+
+  static var staticFoo = () => new E2.f();
+
+  const E2(this.foo);
+
+  factory E2.f() => throw 42;
+
+  int method(int value) => value + 10;
+
+  String staticMethod(double d, X x) => "$d$x";
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/members.dart.strong.expect b/pkg/front_end/testcases/enhanced_enums/members.dart.strong.expect
new file mode 100644
index 0000000..d81899d
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/members.dart.strong.expect
@@ -0,0 +1,68 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = #C9;
+  static const field self::E one = #C5;
+  static const field self::E two = #C8;
+  final field core::int foo;
+  final field core::int bar = 42;
+  static field self::E staticFoo = self::E::f();
+  const constructor •(core::int index, core::String name, core::int foo) → self::E
+    : self::E::foo = foo, super core::_Enum::•(index, name)
+    ;
+  method toString() → core::String
+    return "E.${this.{core::_Enum::_name}{core::String}}";
+  static factory f() → self::E
+    return #C5;
+  method method(core::int value) → core::int
+    return value.{core::num::+}(10){(core::num) → core::int};
+  method staticMethod(core::double d, core::bool b) → core::String
+    return "${d}${b}";
+}
+class E2<X extends core::Object? = dynamic> extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E2<dynamic>> values = #C14;
+  static const field self::E2<core::num> one = #C11;
+  static const field self::E2<core::String> two = #C13;
+  final field self::E2::X% foo;
+  final field self::E2::X? bar = null;
+  static field () → self::E2<dynamic> staticFoo = () → self::E2<dynamic> => self::E2::f<dynamic>();
+  const constructor •(core::int index, core::String name, self::E2::X% foo) → self::E2<self::E2::X%>
+    : self::E2::foo = foo, super core::_Enum::•(index, name)
+    ;
+  method toString() → core::String
+    return "E2.${this.{core::_Enum::_name}{core::String}}";
+  static factory f<X extends core::Object? = dynamic>() → self::E2<dynamic>
+    return throw 42;
+  method method(core::int value) → core::int
+    return value.{core::num::+}(10){(core::num) → core::int};
+  method staticMethod(core::double d, covariant-by-class self::E2::X% x) → core::String
+    return "${d}${x}";
+}
+static method main() → dynamic {}
+
+constants  {
+  #C1 = 1
+  #C2 = 42
+  #C3 = 0
+  #C4 = "one"
+  #C5 = self::E {foo:#C1, bar:#C2, index:#C3, _name:#C4}
+  #C6 = 2
+  #C7 = "two"
+  #C8 = self::E {foo:#C6, bar:#C2, index:#C1, _name:#C7}
+  #C9 = <self::E>[#C5, #C8]
+  #C10 = null
+  #C11 = self::E2<core::num> {foo:#C1, bar:#C10, index:#C3, _name:#C4}
+  #C12 = "2"
+  #C13 = self::E2<core::String> {foo:#C12, bar:#C10, index:#C1, _name:#C7}
+  #C14 = <self::E2<dynamic>>[#C11, #C13]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///members.dart:
+- E. (from org-dartlang-testcase:///members.dart:14:9)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
+- E2. (from org-dartlang-testcase:///members.dart:32:9)
diff --git a/pkg/front_end/testcases/enhanced_enums/members.dart.strong.transformed.expect b/pkg/front_end/testcases/enhanced_enums/members.dart.strong.transformed.expect
new file mode 100644
index 0000000..d81899d
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/members.dart.strong.transformed.expect
@@ -0,0 +1,68 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = #C9;
+  static const field self::E one = #C5;
+  static const field self::E two = #C8;
+  final field core::int foo;
+  final field core::int bar = 42;
+  static field self::E staticFoo = self::E::f();
+  const constructor •(core::int index, core::String name, core::int foo) → self::E
+    : self::E::foo = foo, super core::_Enum::•(index, name)
+    ;
+  method toString() → core::String
+    return "E.${this.{core::_Enum::_name}{core::String}}";
+  static factory f() → self::E
+    return #C5;
+  method method(core::int value) → core::int
+    return value.{core::num::+}(10){(core::num) → core::int};
+  method staticMethod(core::double d, core::bool b) → core::String
+    return "${d}${b}";
+}
+class E2<X extends core::Object? = dynamic> extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E2<dynamic>> values = #C14;
+  static const field self::E2<core::num> one = #C11;
+  static const field self::E2<core::String> two = #C13;
+  final field self::E2::X% foo;
+  final field self::E2::X? bar = null;
+  static field () → self::E2<dynamic> staticFoo = () → self::E2<dynamic> => self::E2::f<dynamic>();
+  const constructor •(core::int index, core::String name, self::E2::X% foo) → self::E2<self::E2::X%>
+    : self::E2::foo = foo, super core::_Enum::•(index, name)
+    ;
+  method toString() → core::String
+    return "E2.${this.{core::_Enum::_name}{core::String}}";
+  static factory f<X extends core::Object? = dynamic>() → self::E2<dynamic>
+    return throw 42;
+  method method(core::int value) → core::int
+    return value.{core::num::+}(10){(core::num) → core::int};
+  method staticMethod(core::double d, covariant-by-class self::E2::X% x) → core::String
+    return "${d}${x}";
+}
+static method main() → dynamic {}
+
+constants  {
+  #C1 = 1
+  #C2 = 42
+  #C3 = 0
+  #C4 = "one"
+  #C5 = self::E {foo:#C1, bar:#C2, index:#C3, _name:#C4}
+  #C6 = 2
+  #C7 = "two"
+  #C8 = self::E {foo:#C6, bar:#C2, index:#C1, _name:#C7}
+  #C9 = <self::E>[#C5, #C8]
+  #C10 = null
+  #C11 = self::E2<core::num> {foo:#C1, bar:#C10, index:#C3, _name:#C4}
+  #C12 = "2"
+  #C13 = self::E2<core::String> {foo:#C12, bar:#C10, index:#C1, _name:#C7}
+  #C14 = <self::E2<dynamic>>[#C11, #C13]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///members.dart:
+- E. (from org-dartlang-testcase:///members.dart:14:9)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
+- E2. (from org-dartlang-testcase:///members.dart:32:9)
diff --git a/pkg/front_end/testcases/enhanced_enums/members.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/members.dart.textual_outline.expect
new file mode 100644
index 0000000..1037478
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/members.dart.textual_outline.expect
@@ -0,0 +1,3 @@
+enum E { one(1), two(2); final int foo; final int bar = 42; static E staticFoo = new E.f(); const E(this.foo); factory E.f() => E.one; int method(int value) => value + 10; String staticMethod(double d, bool b) => "$d$b"; }
+enum E2<X> { one<num>(1), two("2"); final X foo; final X? bar = null; static var staticFoo = () => new E2.f(); const E2(this.foo); factory E2.f() => throw 42; int method(int value) => value + 10; String staticMethod(double d, X x) => "$d$x"; }
+main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/members.dart.weak.expect b/pkg/front_end/testcases/enhanced_enums/members.dart.weak.expect
new file mode 100644
index 0000000..7aa96cc
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/members.dart.weak.expect
@@ -0,0 +1,68 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = #C9;
+  static const field self::E one = #C5;
+  static const field self::E two = #C8;
+  final field core::int foo;
+  final field core::int bar = 42;
+  static field self::E staticFoo = self::E::f();
+  const constructor •(core::int index, core::String name, core::int foo) → self::E
+    : self::E::foo = foo, super core::_Enum::•(index, name)
+    ;
+  method toString() → core::String
+    return "E.${this.{core::_Enum::_name}{core::String}}";
+  static factory f() → self::E
+    return #C5;
+  method method(core::int value) → core::int
+    return value.{core::num::+}(10){(core::num) → core::int};
+  method staticMethod(core::double d, core::bool b) → core::String
+    return "${d}${b}";
+}
+class E2<X extends core::Object? = dynamic> extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E2<dynamic>> values = #C14;
+  static const field self::E2<core::num> one = #C11;
+  static const field self::E2<core::String> two = #C13;
+  final field self::E2::X% foo;
+  final field self::E2::X? bar = null;
+  static field () → self::E2<dynamic> staticFoo = () → self::E2<dynamic> => self::E2::f<dynamic>();
+  const constructor •(core::int index, core::String name, self::E2::X% foo) → self::E2<self::E2::X%>
+    : self::E2::foo = foo, super core::_Enum::•(index, name)
+    ;
+  method toString() → core::String
+    return "E2.${this.{core::_Enum::_name}{core::String}}";
+  static factory f<X extends core::Object? = dynamic>() → self::E2<dynamic>
+    return throw 42;
+  method method(core::int value) → core::int
+    return value.{core::num::+}(10){(core::num) → core::int};
+  method staticMethod(core::double d, covariant-by-class self::E2::X% x) → core::String
+    return "${d}${x}";
+}
+static method main() → dynamic {}
+
+constants  {
+  #C1 = 1
+  #C2 = 42
+  #C3 = 0
+  #C4 = "one"
+  #C5 = self::E {foo:#C1, bar:#C2, index:#C3, _name:#C4}
+  #C6 = 2
+  #C7 = "two"
+  #C8 = self::E {foo:#C6, bar:#C2, index:#C1, _name:#C7}
+  #C9 = <self::E*>[#C5, #C8]
+  #C10 = null
+  #C11 = self::E2<core::num*> {foo:#C1, bar:#C10, index:#C3, _name:#C4}
+  #C12 = "2"
+  #C13 = self::E2<core::String*> {foo:#C12, bar:#C10, index:#C1, _name:#C7}
+  #C14 = <self::E2<dynamic>*>[#C11, #C13]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///members.dart:
+- E. (from org-dartlang-testcase:///members.dart:14:9)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
+- E2. (from org-dartlang-testcase:///members.dart:32:9)
diff --git a/pkg/front_end/testcases/enhanced_enums/members.dart.weak.modular.expect b/pkg/front_end/testcases/enhanced_enums/members.dart.weak.modular.expect
new file mode 100644
index 0000000..7aa96cc
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/members.dart.weak.modular.expect
@@ -0,0 +1,68 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = #C9;
+  static const field self::E one = #C5;
+  static const field self::E two = #C8;
+  final field core::int foo;
+  final field core::int bar = 42;
+  static field self::E staticFoo = self::E::f();
+  const constructor •(core::int index, core::String name, core::int foo) → self::E
+    : self::E::foo = foo, super core::_Enum::•(index, name)
+    ;
+  method toString() → core::String
+    return "E.${this.{core::_Enum::_name}{core::String}}";
+  static factory f() → self::E
+    return #C5;
+  method method(core::int value) → core::int
+    return value.{core::num::+}(10){(core::num) → core::int};
+  method staticMethod(core::double d, core::bool b) → core::String
+    return "${d}${b}";
+}
+class E2<X extends core::Object? = dynamic> extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E2<dynamic>> values = #C14;
+  static const field self::E2<core::num> one = #C11;
+  static const field self::E2<core::String> two = #C13;
+  final field self::E2::X% foo;
+  final field self::E2::X? bar = null;
+  static field () → self::E2<dynamic> staticFoo = () → self::E2<dynamic> => self::E2::f<dynamic>();
+  const constructor •(core::int index, core::String name, self::E2::X% foo) → self::E2<self::E2::X%>
+    : self::E2::foo = foo, super core::_Enum::•(index, name)
+    ;
+  method toString() → core::String
+    return "E2.${this.{core::_Enum::_name}{core::String}}";
+  static factory f<X extends core::Object? = dynamic>() → self::E2<dynamic>
+    return throw 42;
+  method method(core::int value) → core::int
+    return value.{core::num::+}(10){(core::num) → core::int};
+  method staticMethod(core::double d, covariant-by-class self::E2::X% x) → core::String
+    return "${d}${x}";
+}
+static method main() → dynamic {}
+
+constants  {
+  #C1 = 1
+  #C2 = 42
+  #C3 = 0
+  #C4 = "one"
+  #C5 = self::E {foo:#C1, bar:#C2, index:#C3, _name:#C4}
+  #C6 = 2
+  #C7 = "two"
+  #C8 = self::E {foo:#C6, bar:#C2, index:#C1, _name:#C7}
+  #C9 = <self::E*>[#C5, #C8]
+  #C10 = null
+  #C11 = self::E2<core::num*> {foo:#C1, bar:#C10, index:#C3, _name:#C4}
+  #C12 = "2"
+  #C13 = self::E2<core::String*> {foo:#C12, bar:#C10, index:#C1, _name:#C7}
+  #C14 = <self::E2<dynamic>*>[#C11, #C13]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///members.dart:
+- E. (from org-dartlang-testcase:///members.dart:14:9)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
+- E2. (from org-dartlang-testcase:///members.dart:32:9)
diff --git a/pkg/front_end/testcases/enhanced_enums/members.dart.weak.outline.expect b/pkg/front_end/testcases/enhanced_enums/members.dart.weak.outline.expect
new file mode 100644
index 0000000..f6877f8
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/members.dart.weak.outline.expect
@@ -0,0 +1,54 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = const <self::E>[self::E::one, self::E::two];
+  static const field self::E one = const self::E::•(0, "one", 1);
+  static const field self::E two = const self::E::•(1, "two", 2);
+  final field core::int foo;
+  final field core::int bar;
+  static field self::E staticFoo;
+  const constructor •(core::int index, core::String name, core::int foo) → self::E
+    : self::E::foo = foo, super core::_Enum::•(index, name)
+    ;
+  method toString() → core::String
+    return "E.${this.{core::_Enum::_name}{core::String}}";
+  static factory f() → self::E
+    ;
+  method method(core::int value) → core::int
+    ;
+  method staticMethod(core::double d, core::bool b) → core::String
+    ;
+}
+class E2<X extends core::Object? = dynamic> extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E2<dynamic>> values = const <self::E2<dynamic>>[self::E2::one, self::E2::two];
+  static const field self::E2<core::num> one = const self::E2::•<core::num>(0, "one", 1);
+  static const field self::E2<core::String> two = const self::E2::•<core::String>(1, "two", "2");
+  final field self::E2::X% foo;
+  final field self::E2::X? bar;
+  static field () → self::E2<dynamic> staticFoo;
+  const constructor •(core::int index, core::String name, self::E2::X% foo) → self::E2<self::E2::X%>
+    : self::E2::foo = foo, super core::_Enum::•(index, name)
+    ;
+  method toString() → core::String
+    return "E2.${this.{core::_Enum::_name}{core::String}}";
+  static factory f<X extends core::Object? = dynamic>() → self::E2<dynamic>
+    ;
+  method method(core::int value) → core::int
+    ;
+  method staticMethod(core::double d, covariant-by-class self::E2::X% x) → core::String
+    ;
+}
+static method main() → dynamic
+  ;
+
+
+Extra constant evaluation status:
+Evaluated: ListLiteral @ org-dartlang-testcase:///members.dart:5:6 -> ListConstant(const <E*>[const E{E.foo: 1, E.bar: null, _Enum.index: 0, _Enum._name: "one"}, const E{E.foo: 2, E.bar: null, _Enum.index: 1, _Enum._name: "two"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///members.dart:6:3 -> InstanceConstant(const E{E.foo: 1, E.bar: null, _Enum.index: 0, _Enum._name: "one"})
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///members.dart:7:3 -> InstanceConstant(const E{E.foo: 2, E.bar: null, _Enum.index: 1, _Enum._name: "two"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///members.dart:23:6 -> ListConstant(const <E2<dynamic>*>[const E2<num*>{E2.foo: 1, E2.bar: null, _Enum.index: 0, _Enum._name: "one"}, const E2<String*>{E2.foo: "2", E2.bar: null, _Enum.index: 1, _Enum._name: "two"}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///members.dart:24:3 -> InstanceConstant(const E2<num*>{E2.foo: 1, E2.bar: null, _Enum.index: 0, _Enum._name: "one"})
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///members.dart:25:3 -> InstanceConstant(const E2<String*>{E2.foo: "2", E2.bar: null, _Enum.index: 1, _Enum._name: "two"})
+Extra constant evaluation: evaluated: 18, effectively constant: 6
diff --git a/pkg/front_end/testcases/enhanced_enums/members.dart.weak.transformed.expect b/pkg/front_end/testcases/enhanced_enums/members.dart.weak.transformed.expect
new file mode 100644
index 0000000..7aa96cc
--- /dev/null
+++ b/pkg/front_end/testcases/enhanced_enums/members.dart.weak.transformed.expect
@@ -0,0 +1,68 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+class E extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E> values = #C9;
+  static const field self::E one = #C5;
+  static const field self::E two = #C8;
+  final field core::int foo;
+  final field core::int bar = 42;
+  static field self::E staticFoo = self::E::f();
+  const constructor •(core::int index, core::String name, core::int foo) → self::E
+    : self::E::foo = foo, super core::_Enum::•(index, name)
+    ;
+  method toString() → core::String
+    return "E.${this.{core::_Enum::_name}{core::String}}";
+  static factory f() → self::E
+    return #C5;
+  method method(core::int value) → core::int
+    return value.{core::num::+}(10){(core::num) → core::int};
+  method staticMethod(core::double d, core::bool b) → core::String
+    return "${d}${b}";
+}
+class E2<X extends core::Object? = dynamic> extends core::_Enum /*isEnum*/  {
+  static const field core::List<self::E2<dynamic>> values = #C14;
+  static const field self::E2<core::num> one = #C11;
+  static const field self::E2<core::String> two = #C13;
+  final field self::E2::X% foo;
+  final field self::E2::X? bar = null;
+  static field () → self::E2<dynamic> staticFoo = () → self::E2<dynamic> => self::E2::f<dynamic>();
+  const constructor •(core::int index, core::String name, self::E2::X% foo) → self::E2<self::E2::X%>
+    : self::E2::foo = foo, super core::_Enum::•(index, name)
+    ;
+  method toString() → core::String
+    return "E2.${this.{core::_Enum::_name}{core::String}}";
+  static factory f<X extends core::Object? = dynamic>() → self::E2<dynamic>
+    return throw 42;
+  method method(core::int value) → core::int
+    return value.{core::num::+}(10){(core::num) → core::int};
+  method staticMethod(core::double d, covariant-by-class self::E2::X% x) → core::String
+    return "${d}${x}";
+}
+static method main() → dynamic {}
+
+constants  {
+  #C1 = 1
+  #C2 = 42
+  #C3 = 0
+  #C4 = "one"
+  #C5 = self::E {foo:#C1, bar:#C2, index:#C3, _name:#C4}
+  #C6 = 2
+  #C7 = "two"
+  #C8 = self::E {foo:#C6, bar:#C2, index:#C1, _name:#C7}
+  #C9 = <self::E*>[#C5, #C8]
+  #C10 = null
+  #C11 = self::E2<core::num*> {foo:#C1, bar:#C10, index:#C3, _name:#C4}
+  #C12 = "2"
+  #C13 = self::E2<core::String*> {foo:#C12, bar:#C10, index:#C1, _name:#C7}
+  #C14 = <self::E2<dynamic>*>[#C11, #C13]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///members.dart:
+- E. (from org-dartlang-testcase:///members.dart:14:9)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
+- E2. (from org-dartlang-testcase:///members.dart:32:9)
diff --git a/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.expect b/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.expect
index dfe0844..d038898 100644
--- a/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.expect
+++ b/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.expect
@@ -3,7 +3,7 @@
 // Problems in library:
 //
 // pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart:11:6: Error: This requires the 'extension-types' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // test(E e) {} // Error.
 //      ^
 //
diff --git a/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.modular.expect b/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.modular.expect
index dfe0844..d038898 100644
--- a/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.modular.expect
@@ -3,7 +3,7 @@
 // Problems in library:
 //
 // pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart:11:6: Error: This requires the 'extension-types' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // test(E e) {} // Error.
 //      ^
 //
diff --git a/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.outline.expect b/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.outline.expect
index 7be45bb..05bcb32 100644
--- a/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.outline.expect
@@ -3,7 +3,7 @@
 // Problems in library:
 //
 // pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart:11:6: Error: This requires the 'extension-types' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // test(E e) {} // Error.
 //      ^
 //
diff --git a/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.transformed.expect b/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.transformed.expect
index dfe0844..d038898 100644
--- a/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart.weak.transformed.expect
@@ -3,7 +3,7 @@
 // Problems in library:
 //
 // pkg/front_end/testcases/general/extension_type_when_experiment_not_enabled.dart:11:6: Error: This requires the 'extension-types' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // test(E e) {} // Error.
 //      ^
 //
diff --git a/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.expect b/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.expect
index 0c596cb..1fcab84f 100644
--- a/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.expect
+++ b/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.expect
@@ -3,7 +3,7 @@
 // Problems in library:
 //
 // pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart:9:11: Error: This requires the 'extension-types' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // extension type E on A {} // Error because of 'type'.
 //           ^^^^
 //
diff --git a/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.modular.expect b/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.modular.expect
index 0c596cb..1fcab84f 100644
--- a/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.modular.expect
@@ -3,7 +3,7 @@
 // Problems in library:
 //
 // pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart:9:11: Error: This requires the 'extension-types' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // extension type E on A {} // Error because of 'type'.
 //           ^^^^
 //
diff --git a/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.outline.expect b/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.outline.expect
index 8b21c25..9141057 100644
--- a/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.outline.expect
@@ -3,7 +3,7 @@
 // Problems in library:
 //
 // pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart:9:11: Error: This requires the 'extension-types' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // extension type E on A {} // Error because of 'type'.
 //           ^^^^
 //
diff --git a/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.transformed.expect b/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.transformed.expect
index 0c596cb..1fcab84f 100644
--- a/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart.weak.transformed.expect
@@ -3,7 +3,7 @@
 // Problems in library:
 //
 // pkg/front_end/testcases/general/extension_types_feature_not_enabled.dart:9:11: Error: This requires the 'extension-types' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // extension type E on A {} // Error because of 'type'.
 //           ^^^^
 //
diff --git a/pkg/front_end/testcases/general/issue48090.dart b/pkg/front_end/testcases/general/issue48090.dart
new file mode 100644
index 0000000..5164441
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue48090.dart
@@ -0,0 +1,13 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:isolate';
+
+void main() {
+  String debugName = Isolate.current.debugName ?? ''; // ok
+}
+
+void test() {
+  String debugName = Isolate.current.debugName; // error
+}
diff --git a/pkg/front_end/testcases/general/issue48090.dart.textual_outline.expect b/pkg/front_end/testcases/general/issue48090.dart.textual_outline.expect
new file mode 100644
index 0000000..9ab0a0f
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue48090.dart.textual_outline.expect
@@ -0,0 +1,4 @@
+import 'dart:isolate';
+
+void main() {}
+void test() {}
diff --git a/pkg/front_end/testcases/general/issue48090.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/issue48090.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..9ab0a0f
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue48090.dart.textual_outline_modelled.expect
@@ -0,0 +1,4 @@
+import 'dart:isolate';
+
+void main() {}
+void test() {}
diff --git a/pkg/front_end/testcases/general/issue48090.dart.weak.expect b/pkg/front_end/testcases/general/issue48090.dart.weak.expect
new file mode 100644
index 0000000..9a0be82
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue48090.dart.weak.expect
@@ -0,0 +1,22 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/issue48090.dart:12:38: Error: A value of type 'String?' can't be assigned to a variable of type 'String' because 'String?' is nullable and 'String' isn't.
+//   String debugName = Isolate.current.debugName; // error
+//                                      ^
+//
+import self as self;
+import "dart:core" as core;
+import "dart:isolate" as iso;
+
+import "dart:isolate";
+
+static method main() → void {
+  core::String debugName = let final core::String? #t1 = iso::Isolate::current.{iso::Isolate::debugName}{core::String?} in #t1 == null ?{core::String} "" : #t1{core::String};
+}
+static method test() → void {
+  core::String debugName = invalid-expression "pkg/front_end/testcases/general/issue48090.dart:12:38: Error: A value of type 'String?' can't be assigned to a variable of type 'String' because 'String?' is nullable and 'String' isn't.
+  String debugName = Isolate.current.debugName; // error
+                                     ^" in iso::Isolate::current.{iso::Isolate::debugName}{core::String?} as{TypeError,ForNonNullableByDefault} core::String;
+}
diff --git a/pkg/front_end/testcases/general/issue48090.dart.weak.modular.expect b/pkg/front_end/testcases/general/issue48090.dart.weak.modular.expect
new file mode 100644
index 0000000..9a0be82
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue48090.dart.weak.modular.expect
@@ -0,0 +1,22 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/issue48090.dart:12:38: Error: A value of type 'String?' can't be assigned to a variable of type 'String' because 'String?' is nullable and 'String' isn't.
+//   String debugName = Isolate.current.debugName; // error
+//                                      ^
+//
+import self as self;
+import "dart:core" as core;
+import "dart:isolate" as iso;
+
+import "dart:isolate";
+
+static method main() → void {
+  core::String debugName = let final core::String? #t1 = iso::Isolate::current.{iso::Isolate::debugName}{core::String?} in #t1 == null ?{core::String} "" : #t1{core::String};
+}
+static method test() → void {
+  core::String debugName = invalid-expression "pkg/front_end/testcases/general/issue48090.dart:12:38: Error: A value of type 'String?' can't be assigned to a variable of type 'String' because 'String?' is nullable and 'String' isn't.
+  String debugName = Isolate.current.debugName; // error
+                                     ^" in iso::Isolate::current.{iso::Isolate::debugName}{core::String?} as{TypeError,ForNonNullableByDefault} core::String;
+}
diff --git a/pkg/front_end/testcases/general/issue48090.dart.weak.outline.expect b/pkg/front_end/testcases/general/issue48090.dart.weak.outline.expect
new file mode 100644
index 0000000..bc35ad4
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue48090.dart.weak.outline.expect
@@ -0,0 +1,9 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+
+import "dart:isolate";
+
+static method main() → void
+  ;
+static method test() → void
+  ;
diff --git a/pkg/front_end/testcases/general/issue48090.dart.weak.transformed.expect b/pkg/front_end/testcases/general/issue48090.dart.weak.transformed.expect
new file mode 100644
index 0000000..7288854
--- /dev/null
+++ b/pkg/front_end/testcases/general/issue48090.dart.weak.transformed.expect
@@ -0,0 +1,22 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/general/issue48090.dart:12:38: Error: A value of type 'String?' can't be assigned to a variable of type 'String' because 'String?' is nullable and 'String' isn't.
+//   String debugName = Isolate.current.debugName; // error
+//                                      ^
+//
+import self as self;
+import "dart:core" as core;
+import "dart:isolate" as iso;
+
+import "dart:isolate";
+
+static method main() → void {
+  core::String debugName = let final core::String? #t1 = iso::Isolate::current.{iso::Isolate::debugName}{core::String?} in #t1 == null ?{core::String} "" : #t1{core::String};
+}
+static method test() → void {
+  core::String debugName = invalid-expression "pkg/front_end/testcases/general/issue48090.dart:12:38: Error: A value of type 'String?' can't be assigned to a variable of type 'String' because 'String?' is nullable and 'String' isn't.
+  String debugName = Isolate.current.debugName; // error
+                                     ^" in iso::Isolate::current.{iso::Isolate::debugName}{core::String?};
+}
diff --git a/pkg/front_end/testcases/general/macro_class.dart.weak.expect b/pkg/front_end/testcases/general/macro_class.dart.weak.expect
index 5a61151..ce6b7bb 100644
--- a/pkg/front_end/testcases/general/macro_class.dart.weak.expect
+++ b/pkg/front_end/testcases/general/macro_class.dart.weak.expect
@@ -3,22 +3,22 @@
 // Problems in library:
 //
 // pkg/front_end/testcases/general/macro_class.dart:8:7: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // macro class Class1 {}
 //       ^^^^^
 //
 // pkg/front_end/testcases/general/macro_class.dart:9:16: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // abstract macro class Class2 {}
 //                ^^^^^
 //
 // pkg/front_end/testcases/general/macro_class.dart:10:7: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // macro class Class3 = Super with Mixin;
 //       ^^^^^
 //
 // pkg/front_end/testcases/general/macro_class.dart:11:16: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // abstract macro class Class4 = Super with Mixin;
 //                ^^^^^
 //
diff --git a/pkg/front_end/testcases/general/macro_class.dart.weak.modular.expect b/pkg/front_end/testcases/general/macro_class.dart.weak.modular.expect
index 5a61151..ce6b7bb 100644
--- a/pkg/front_end/testcases/general/macro_class.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/macro_class.dart.weak.modular.expect
@@ -3,22 +3,22 @@
 // Problems in library:
 //
 // pkg/front_end/testcases/general/macro_class.dart:8:7: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // macro class Class1 {}
 //       ^^^^^
 //
 // pkg/front_end/testcases/general/macro_class.dart:9:16: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // abstract macro class Class2 {}
 //                ^^^^^
 //
 // pkg/front_end/testcases/general/macro_class.dart:10:7: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // macro class Class3 = Super with Mixin;
 //       ^^^^^
 //
 // pkg/front_end/testcases/general/macro_class.dart:11:16: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // abstract macro class Class4 = Super with Mixin;
 //                ^^^^^
 //
diff --git a/pkg/front_end/testcases/general/macro_class.dart.weak.outline.expect b/pkg/front_end/testcases/general/macro_class.dart.weak.outline.expect
index 13e7bcc..614ee32 100644
--- a/pkg/front_end/testcases/general/macro_class.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/general/macro_class.dart.weak.outline.expect
@@ -3,22 +3,22 @@
 // Problems in library:
 //
 // pkg/front_end/testcases/general/macro_class.dart:8:7: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // macro class Class1 {}
 //       ^^^^^
 //
 // pkg/front_end/testcases/general/macro_class.dart:9:16: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // abstract macro class Class2 {}
 //                ^^^^^
 //
 // pkg/front_end/testcases/general/macro_class.dart:10:7: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // macro class Class3 = Super with Mixin;
 //       ^^^^^
 //
 // pkg/front_end/testcases/general/macro_class.dart:11:16: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // abstract macro class Class4 = Super with Mixin;
 //                ^^^^^
 //
diff --git a/pkg/front_end/testcases/general/macro_class.dart.weak.transformed.expect b/pkg/front_end/testcases/general/macro_class.dart.weak.transformed.expect
index 506e808..7f71bca 100644
--- a/pkg/front_end/testcases/general/macro_class.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/macro_class.dart.weak.transformed.expect
@@ -3,22 +3,22 @@
 // Problems in library:
 //
 // pkg/front_end/testcases/general/macro_class.dart:8:7: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // macro class Class1 {}
 //       ^^^^^
 //
 // pkg/front_end/testcases/general/macro_class.dart:9:16: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // abstract macro class Class2 {}
 //                ^^^^^
 //
 // pkg/front_end/testcases/general/macro_class.dart:10:7: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // macro class Class3 = Super with Mixin;
 //       ^^^^^
 //
 // pkg/front_end/testcases/general/macro_class.dart:11:16: Error: This requires the 'macros' language feature to be enabled.
-// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.16 or higher, and running 'pub get'.
+// Try updating your pubspec.yaml to set the minimum SDK constraint to 2.17 or higher, and running 'pub get'.
 // abstract macro class Class4 = Super with Mixin;
 //                ^^^^^
 //
diff --git a/pkg/front_end/testcases/textual_outline.status b/pkg/front_end/testcases/textual_outline.status
index 386be8a..6736b08 100644
--- a/pkg/front_end/testcases/textual_outline.status
+++ b/pkg/front_end/testcases/textual_outline.status
@@ -30,6 +30,8 @@
 dart2js/late_statics: FormatterCrash
 enhanced_enums/entries_with_type_arguments: FormatterCrash
 enhanced_enums/inference_in_constructor_parameters: FormatterCrash
+enhanced_enums/issue48084: FormatterCrash
+enhanced_enums/members: FormatterCrash
 enhanced_enums/qualified_names_with_no_type_arguments: FormatterCrash
 enhanced_enums/redirecting_initializers: FormatterCrash
 enhanced_enums/simple_fields: FormatterCrash
diff --git a/pkg/front_end/tool/smoke_test_quick.dart b/pkg/front_end/tool/smoke_test_quick.dart
index 2b7a200..12b77c3 100644
--- a/pkg/front_end/tool/smoke_test_quick.dart
+++ b/pkg/front_end/tool/smoke_test_quick.dart
@@ -29,9 +29,6 @@
   futures.add(run(
       "pkg/front_end/test/generated_files_up_to_date_git_test.dart", [],
       filter: false));
-  futures.add(run("tools/yaml2json.dart",
-      ["sdk/lib/libraries.yaml", "sdk/lib/libraries.json", '--check'],
-      filter: false));
   await Future.wait(futures);
   print("\n-----------------------\n");
   print("Done with exitcode $exitCode in ${stopwatch.elapsedMilliseconds} ms");
diff --git a/pkg/kernel/lib/default_language_version.dart b/pkg/kernel/lib/default_language_version.dart
index d4c3163..cc7de77 100644
--- a/pkg/kernel/lib/default_language_version.dart
+++ b/pkg/kernel/lib/default_language_version.dart
@@ -9,4 +9,4 @@
 
 import "ast.dart";
 
-Version defaultLanguageVersion = const Version(2, 16);
+Version defaultLanguageVersion = const Version(2, 17);
diff --git a/pkg/test_runner/lib/src/configuration.dart b/pkg/test_runner/lib/src/configuration.dart
index 51110c0..198c01a 100644
--- a/pkg/test_runner/lib/src/configuration.dart
+++ b/pkg/test_runner/lib/src/configuration.dart
@@ -64,6 +64,7 @@
       this.keepGeneratedFiles,
       this.sharedOptions,
       String packages,
+      this.serviceResponseSizesDirectory,
       this.suiteDirectory,
       this.outputDirectory,
       this.reproducingArguments,
@@ -176,6 +177,7 @@
     return _packages;
   }
 
+  final String serviceResponseSizesDirectory;
   final String outputDirectory;
   final String suiteDirectory;
   String get babel => configuration.babel;
diff --git a/pkg/test_runner/lib/src/options.dart b/pkg/test_runner/lib/src/options.dart
index dccb5f4..142b123 100644
--- a/pkg/test_runner/lib/src/options.dart
+++ b/pkg/test_runner/lib/src/options.dart
@@ -338,7 +338,10 @@
         hide: true),
     _Option.bool('print_passing_stdout',
         'Print the stdout of passing, as well as failing, tests.',
-        hide: true)
+        hide: true),
+    _Option('service_response_sizes_directory',
+        'Log VM service response sizes in CSV files in the provided directory',
+        hide: true),
   ];
 
   /// For printing out reproducing command lines, we don't want to add these
@@ -777,6 +780,8 @@
           localIP: data["local_ip"] as String,
           sharedOptions: sharedOptions,
           packages: data["packages"] as String,
+          serviceResponseSizesDirectory:
+              data['service_response_sizes_directory'] as String,
           suiteDirectory: data["suite_dir"] as String,
           outputDirectory: data["output_directory"] as String,
           reproducingArguments:
diff --git a/pkg/test_runner/lib/src/test_suite.dart b/pkg/test_runner/lib/src/test_suite.dart
index 9a5d685..bae578b 100644
--- a/pkg/test_runner/lib/src/test_suite.dart
+++ b/pkg/test_runner/lib/src/test_suite.dart
@@ -763,6 +763,8 @@
           ...vmOptionsList[vmOptionsVariant],
           ...extraVmOptions,
           if (emitDdsTest) '-DUSE_DDS=true',
+          if (configuration.serviceResponseSizesDirectory != null)
+            '-DSERVICE_RESPONSE_SIZES_DIR=${configuration.serviceResponseSizesDirectory}',
         ];
         var isCrashExpected = expectations.contains(Expectation.crash);
         var commands = _makeCommands(
diff --git a/pkg/vm/lib/transformations/type_flow/transformer.dart b/pkg/vm/lib/transformations/type_flow/transformer.dart
index d82925a..6533e54 100644
--- a/pkg/vm/lib/transformations/type_flow/transformer.dart
+++ b/pkg/vm/lib/transformations/type_flow/transformer.dart
@@ -1583,12 +1583,22 @@
     if (_isExtendedBoolLiteral(condition)) {
       final bool value = _getExtendedBoolLiteralValue(condition);
       final Expression expr = transform(value ? node.then : node.otherwise);
+      Expression result;
       if (condition is BlockExpression) {
         condition.value = expr;
         expr.parent = condition;
-        return condition;
+        result = condition;
       } else {
-        return expr;
+        result = expr;
+      }
+      if (node.staticType != result.getStaticType(staticTypeContext)) {
+        return StaticInvocation(
+            unsafeCast,
+            Arguments([result],
+                types: [visitDartType(node.staticType, cannotRemoveSentinel)]))
+          ..fileOffset = node.fileOffset;
+      } else {
+        return result;
       }
     }
     node.condition = condition..parent = node;
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/null_test_elimination2_nnbd_strong.dart b/pkg/vm/testcases/transformations/type_flow/transformer/null_test_elimination2_nnbd_strong.dart
new file mode 100644
index 0000000..47a6a15
--- /dev/null
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/null_test_elimination2_nnbd_strong.dart
@@ -0,0 +1,20 @@
+// Copyright (c) 2022, 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 elimination of null test in a conditional expression of
+// a different static type.
+
+bool _defaultCheck([dynamic _]) => true;
+
+void testStaticTypeOfConditional<T>(bool Function(T error)? check, Object e) {
+  // Verify that null test elimination leaves unsafeCast here to
+  // keep static type of 'check ?? _defaultCheck' expression.
+  if (e is T && (check ?? _defaultCheck)(e)) {
+    print('ok');
+  }
+}
+
+void main() {
+  testStaticTypeOfConditional<String>((_) => true, 'hi');
+}
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/null_test_elimination2_nnbd_strong.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/null_test_elimination2_nnbd_strong.dart.expect
new file mode 100644
index 0000000..de2490b
--- /dev/null
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/null_test_elimination2_nnbd_strong.dart.expect
@@ -0,0 +1,19 @@
+library #lib /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+import "dart:_internal" as _in;
+
+static method _defaultCheck([dynamic _ = #C1]) → core::bool
+  return true;
+static method testStaticTypeOfConditional<T extends core::Object? = dynamic>([@vm.inferred-type.metadata=!] (self::testStaticTypeOfConditional::T%) →? core::bool check) → void {
+  if(#C2 is{ForNonNullableByDefault} self::testStaticTypeOfConditional::T% && (let final (self::testStaticTypeOfConditional::T%) →? core::bool #t1 = check in _in::unsafeCast<core::Function>(#t1{(self::testStaticTypeOfConditional::T%) → core::bool}))(#C2) as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool) {
+    core::print("ok");
+  }
+}
+static method main() → void {
+  self::testStaticTypeOfConditional<core::String>((core::String _) → core::bool => true);
+}
+constants  {
+  #C1 = null
+  #C2 = "hi"
+}
diff --git a/pkg/vm_service/test/common/test_helper.dart b/pkg/vm_service/test/common/test_helper.dart
index e16e307d..62ced95 100644
--- a/pkg/vm_service/test/common/test_helper.dart
+++ b/pkg/vm_service/test/common/test_helper.dart
@@ -107,6 +107,7 @@
     bool pause_on_unhandled_exceptions,
     bool testeeControlsServer,
     bool useAuthToken,
+    List<String>? experiments,
     List<String>? extraArgs,
   ) {
     return _spawnDartProcess(
@@ -115,6 +116,7 @@
         pause_on_unhandled_exceptions,
         testeeControlsServer,
         useAuthToken,
+        experiments,
         extraArgs);
   }
 
@@ -124,6 +126,7 @@
       bool pause_on_unhandled_exceptions,
       bool testeeControlsServer,
       bool useAuthToken,
+      List<String>? experiments,
       List<String>? extraArgs) {
     String dartExecutable = io.Platform.executable;
 
@@ -143,6 +146,9 @@
       fullArgs.add('--pause-isolates-on-unhandled-exceptions');
     }
     fullArgs.add('--profiler');
+    if (experiments != null) {
+      fullArgs.addAll(experiments.map((e) => '--enable-experiment=$e'));
+    }
     if (extraArgs != null) {
       fullArgs.addAll(extraArgs);
     }
@@ -152,7 +158,6 @@
       fullArgs.add('--enable-vm-service:0');
     }
     fullArgs.addAll(args);
-
     return _spawnCommon(dartExecutable, fullArgs, <String, String>{});
   }
 
@@ -180,6 +185,7 @@
       bool pause_on_unhandled_exceptions,
       bool testeeControlsServer,
       bool useAuthToken,
+      List<String>? experiments,
       List<String>? extraArgs) {
     return _spawnProcess(
             pause_on_start,
@@ -187,6 +193,7 @@
             pause_on_unhandled_exceptions,
             testeeControlsServer,
             useAuthToken,
+            experiments,
             extraArgs)
         .then((p) {
       Completer<Uri> completer = Completer<Uri>();
@@ -247,25 +254,27 @@
 }
 
 class _ServiceTesterRunner {
-  Future run(
-      {List<String>? mainArgs,
-      List<String>? extraArgs,
-      List<VMTest>? vmTests,
-      List<IsolateTest>? isolateTests,
-      required String scriptName,
-      bool pause_on_start = false,
-      bool pause_on_exit = false,
-      bool verbose_vm = false,
-      bool pause_on_unhandled_exceptions = false,
-      bool testeeControlsServer = false,
-      bool useAuthToken = false}) async {
+  Future run({
+    List<String>? mainArgs,
+    List<String>? extraArgs,
+    List<String>? experiments,
+    List<VMTest>? vmTests,
+    List<IsolateTest>? isolateTests,
+    required String scriptName,
+    bool pause_on_start = false,
+    bool pause_on_exit = false,
+    bool verbose_vm = false,
+    bool pause_on_unhandled_exceptions = false,
+    bool testeeControlsServer = false,
+    bool useAuthToken = false,
+  }) async {
     var process = _ServiceTesteeLauncher(scriptName);
     late VmService vm;
     late IsolateRef isolate;
     setUp(() async {
       await process
           .launch(pause_on_start, pause_on_exit, pause_on_unhandled_exceptions,
-              testeeControlsServer, useAuthToken, extraArgs)
+              testeeControlsServer, useAuthToken, experiments, extraArgs)
           .then((Uri serverAddress) async {
         if (mainArgs!.contains("--gdb")) {
           var pid = process.process!.pid;
@@ -277,7 +286,6 @@
         vm = await vmServiceConnectUri(serviceWebsocketAddress);
         print('Done loading VM');
         isolate = await getFirstIsolate(vm);
-        print('Got first isolate');
       });
     });
 
@@ -327,13 +335,11 @@
     Completer<dynamic>? completer = Completer();
     late StreamSubscription subscription;
     subscription = service.onIsolateEvent.listen((Event event) async {
-      print('Isolate event: $event');
       if (completer == null) {
         await subscription.cancel();
         return;
       }
       if (event.kind == EventKind.kIsolateRunnable) {
-        print(event.isolate!.name);
         vm = await service.getVM();
         await subscription.cancel();
         await service.streamCancel(EventStreams.kIsolate);
@@ -372,6 +378,7 @@
   bool pause_on_unhandled_exceptions = false,
   bool testeeControlsServer = false,
   bool useAuthToken = false,
+  List<String>? experiments,
   List<String>? extraArgs,
 }) async {
   assert(!pause_on_start || testeeBefore == null);
@@ -390,6 +397,7 @@
         pause_on_start: pause_on_start,
         pause_on_exit: pause_on_exit,
         verbose_vm: verbose_vm,
+        experiments: experiments,
         pause_on_unhandled_exceptions: pause_on_unhandled_exceptions,
         testeeControlsServer: testeeControlsServer,
         useAuthToken: useAuthToken);
diff --git a/pkg/vm_service/test/eval_named_args_anywhere_test.dart b/pkg/vm_service/test/eval_named_args_anywhere_test.dart
new file mode 100644
index 0000000..ad01d46
--- /dev/null
+++ b/pkg/vm_service/test/eval_named_args_anywhere_test.dart
@@ -0,0 +1,72 @@
+// Copyright (c) 2022, 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.
+
+// @dart=2.17
+// ignore_for_file: unused_element
+
+import 'dart:developer';
+import 'package:test/test.dart';
+import 'package:vm_service/vm_service.dart';
+import 'common/service_test_common.dart';
+import 'common/test_helper.dart';
+
+int foo(int a, {required int b}) {
+  return a - b;
+}
+
+class _MyClass {
+  int foo(int a, {required int b}) {
+    return a - b;
+  }
+
+  static int baz(int a, {required int b}) {
+    return a - b;
+  }
+}
+
+void testFunction() {
+  debugger();
+}
+
+final tests = <IsolateTest>[
+  hasStoppedAtBreakpoint,
+  (VmService service, IsolateRef isolateRef) async {
+    final isolateId = isolateRef.id!;
+    final isolate = await service.getIsolate(isolateId);
+
+    final rootLibId = isolate.rootLib!.id!;
+
+    // Evaluate top-level function
+    var result = await service.evaluate(
+      isolateId,
+      rootLibId,
+      'foo(b: 10, 50)',
+    ) as InstanceRef;
+    expect(result.valueAsString, '40');
+
+    // Evaluate class instance method
+    result = await service.evaluate(
+      isolateId,
+      rootLibId,
+      '_MyClass().foo(b: 10, 50)',
+    ) as InstanceRef;
+    expect(result.valueAsString, '40');
+
+    // Evaluate static method
+    result = await service.evaluate(
+      isolateId,
+      rootLibId,
+      '_MyClass.baz(b: 10, 50)',
+    ) as InstanceRef;
+    expect(result.valueAsString, '40');
+  },
+];
+
+main([args = const <String>[]]) => runIsolateTests(
+      args,
+      tests,
+      'eval_named_args_anywhere_test.dart',
+      testeeConcurrent: testFunction,
+      experiments: ['named-arguments-anywhere'],
+    );
diff --git a/runtime/bin/ffi_test/ffi_test_functions_vmspecific.cc b/runtime/bin/ffi_test/ffi_test_functions_vmspecific.cc
index cf10a4e..6b546ad 100644
--- a/runtime/bin/ffi_test/ffi_test_functions_vmspecific.cc
+++ b/runtime/bin/ffi_test/ffi_test_functions_vmspecific.cc
@@ -906,6 +906,34 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// Helpers used for isolate exit tests.
+////////////////////////////////////////////////////////////////////////////////
+
+// This method consumes and ignores unwind error raised by `Isolate.exit` called
+// by dart `callIsolateExit` method.
+DART_EXPORT void IsolateExitTest_LookupAndCallIsolateExit(int i) {
+  Dart_Handle root_lib = Dart_RootLibrary();
+  fprintf(stderr, "IsolateExitTest_LookupAndCallIsolateExit i:%d\n", i);
+  if (i > 0) {
+    Dart_Handle method_name =
+        Dart_NewStringFromCString("recurseLookupAndCallWorker");
+    Dart_Handle dart_args[1];
+    dart_args[0] = Dart_NewInteger(i - 1);
+    Dart_Handle result = Dart_Invoke(root_lib, method_name, 1, dart_args);
+    ENSURE(Dart_IsError(result));
+  } else {
+    Dart_Handle method_name = Dart_NewStringFromCString("callIsolateExit");
+    Dart_Handle result = Dart_Invoke(root_lib, method_name, 0, NULL);
+    if (Dart_IsError(result)) {
+      fprintf(stderr,
+              "%d failed to invoke %s in child isolate: %s, carrying on..\n", i,
+              "callIsolateExit", Dart_GetError(result));
+    }
+    ENSURE(Dart_IsError(result));
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // Functions for handle tests.
 //
 // vmspecific_handle_test.dart (statically linked).
diff --git a/runtime/observatory/tests/service/test_helper.dart b/runtime/observatory/tests/service/test_helper.dart
index 487c098..a0e0c19 100644
--- a/runtime/observatory/tests/service/test_helper.dart
+++ b/runtime/observatory/tests/service/test_helper.dart
@@ -18,6 +18,10 @@
 /// Determines whether DDS is enabled for this test run.
 const bool useDds = const bool.fromEnvironment('USE_DDS');
 
+/// The directory to output VM service response size data files to.
+const String serviceResponseSizesDir =
+    const String.fromEnvironment('SERVICE_RESPONSE_SIZES_DIR');
+
 /// The extra arguments to use
 const List<String> extraDebuggingArgs = ['--lazy-async-stacks'];
 
@@ -178,6 +182,15 @@
     if (!testeeControlsServer) {
       fullArgs.add('--enable-vm-service:$port');
     }
+    if (serviceResponseSizesDir != null) {
+      // Dump service response size details to a CSV. This feature is not used
+      // on the build bots and the generated output will persist after the test
+      // has completed.
+      final dir = path.prettyUri(serviceResponseSizesDir);
+      final testName = path.withoutExtension(path.basename(args.last));
+      final logName = '${testName}_${useDds ? "" : "no_"}dds_sizes.csv';
+      fullArgs.add('--log_service_response_sizes=$dir/$logName');
+    }
     fullArgs.addAll(args);
 
     return _spawnCommon(dartExecutable, fullArgs, <String, String>{});
diff --git a/runtime/observatory_2/tests/service_2/test_helper.dart b/runtime/observatory_2/tests/service_2/test_helper.dart
index 86e7b13..6c782b8 100644
--- a/runtime/observatory_2/tests/service_2/test_helper.dart
+++ b/runtime/observatory_2/tests/service_2/test_helper.dart
@@ -20,6 +20,10 @@
 /// Determines whether DDS is enabled for this test run.
 const bool useDds = const bool.fromEnvironment('USE_DDS');
 
+/// The directory to output VM service response size data files to.
+const String serviceResponseSizesDir =
+    const String.fromEnvironment('SERVICE_RESPONSE_SIZES_DIR');
+
 /// The extra arguments to use
 const List<String> extraDebuggingArgs = ['--lazy-async-stacks'];
 
@@ -178,6 +182,15 @@
     if (!testeeControlsServer) {
       fullArgs.add('--enable-vm-service:$port');
     }
+    if (serviceResponseSizesDir != null) {
+      // Dump service response size details to a CSV. This feature is not used
+      // on the build bots and the generated output will persist after the test
+      // has completed.
+      final dir = path.prettyUri(serviceResponseSizesDir);
+      final testName = path.withoutExtension(path.basename(args.last));
+      final logName = '${testName}_${useDds ? "" : "no_"}dds_sizes.csv';
+      fullArgs.add('--log_service_response_sizes=$dir/$logName');
+    }
     fullArgs.addAll(args);
 
     return _spawnCommon(dartExecutable, fullArgs, <String, String>{});
diff --git a/runtime/tests/vm/dart/isolate_exit_sandwich_test.dart b/runtime/tests/vm/dart/isolate_exit_sandwich_test.dart
new file mode 100644
index 0000000..8a49598
--- /dev/null
+++ b/runtime/tests/vm/dart/isolate_exit_sandwich_test.dart
@@ -0,0 +1,51 @@
+// Copyright (c) 2021, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+//
+// Checks that Kill message (generated for example by Isolate.exit) prevents
+// any more dart code being executed - in particular when dart code with
+// Isolate.exit() is invoked from native code, which in turns is invoked
+// from dart code(hence "sandwich"-test).
+
+import 'dart:async';
+import 'dart:ffi';
+import 'dart:io';
+import 'dart:isolate';
+
+import "package:expect/expect.dart";
+import '../../../../tests/ffi/dylib_utils.dart';
+
+final ffiTestFunctions = dlopenPlatformSpecific('ffi_test_functions');
+
+final lookupAndCallWorkerThatCallsIsolateExit =
+    ffiTestFunctions.lookupFunction<Void Function(Int64), void Function(int)>(
+        'IsolateExitTest_LookupAndCallIsolateExit');
+
+@pragma('vm:entry-point')
+void recurseLookupAndCallWorker(int i) {
+  lookupAndCallWorkerThatCallsIsolateExit(i);
+  print(
+      'coming back after $i invocation of lookupAndCallWorkerThatCallsIsolateExit');
+  assert(false);
+}
+
+// This method is looked up and called by ffi method that ignores unwinding
+// error raised by 'Isolate.exit'.
+@pragma('vm:entry-point')
+Never callIsolateExit() {
+  Isolate.exit();
+}
+
+main(List<String> args) async {
+  if (args.length > 0) {
+    lookupAndCallWorkerThatCallsIsolateExit(4);
+    print('got back');
+    return;
+  }
+  ProcessResult result = await Process.run(
+      Platform.executable, <String>[Platform.script.toString(), 'worker']);
+  Expect.isTrue(result.exitCode != 0);
+  // The child process should be terminated before it had a chance
+  // to print "got back".
+  Expect.isFalse(result.stdout.contains('got back'));
+}
diff --git a/runtime/tests/vm/dart/untyped_function_invocation_with_known_function_type_test.dart b/runtime/tests/vm/dart/untyped_function_invocation_with_known_function_type_test.dart
new file mode 100644
index 0000000..9c16501
--- /dev/null
+++ b/runtime/tests/vm/dart/untyped_function_invocation_with_known_function_type_test.dart
@@ -0,0 +1,27 @@
+// Copyright (c) 2022, 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.
+
+// Verifies that compiler doesn't crash when it sees untyped function
+// invocation (FunctionAccessKind.Function) but receiver has a known
+// function type.
+
+import "package:expect/expect.dart";
+
+bool ok = false;
+bool _defaultCheck([dynamic _]) => true;
+
+void foo<T>(bool Function(T error)? check, Object e) {
+  // Function call on the result of 'check ?? _defaultCheck' is untyped
+  // (assumes static type Function). However, AOT compiler can eliminate
+  // null test and might be able to reduce the expression to 'check' with
+  // known function type.
+  if (e is T && (check ?? _defaultCheck)(e)) {
+    ok = true;
+  }
+}
+
+void main() {
+  foo<String>((_) => true, 'hi');
+  Expect.isTrue(ok);
+}
diff --git a/runtime/tests/vm/dart_2/isolate_exit_sandwich_test.dart b/runtime/tests/vm/dart_2/isolate_exit_sandwich_test.dart
new file mode 100644
index 0000000..0b0a08c
--- /dev/null
+++ b/runtime/tests/vm/dart_2/isolate_exit_sandwich_test.dart
@@ -0,0 +1,52 @@
+// Copyright (c) 2021, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+//
+// Checks that Kill message (generated for example by Isolate.exit) prevents
+// any more dart code being executed - in particular when dart code with
+// Isolate.exit() is invoked from native code, which in turns is invoked
+// from dart code(hence "sandwich"-test).
+
+// @dart = 2.9
+
+import 'dart:async';
+import 'dart:ffi';
+import 'dart:io';
+import 'dart:isolate';
+
+import "package:expect/expect.dart";
+import '../../../../tests/ffi/dylib_utils.dart';
+
+final ffiTestFunctions = dlopenPlatformSpecific('ffi_test_functions');
+
+final lookupAndCallWorkerThatCallsIsolateExit =
+    ffiTestFunctions.lookupFunction<Void Function(Int64), void Function(int)>(
+        'IsolateExitTest_LookupAndCallIsolateExit');
+
+@pragma('vm:entry-point')
+void recurseLookupAndCallWorker(int i) {
+  lookupAndCallWorkerThatCallsIsolateExit(i);
+  print(
+      'coming back after $i invocation of lookupAndCallWorkerThatCallsIsolateExit');
+}
+
+// This method is looked up and called by ffi method that ignores unwinding
+// error raised by 'Isolate.exit'.
+@pragma('vm:entry-point')
+Never callIsolateExit() {
+  Isolate.exit();
+}
+
+main(List<String> args) async {
+  if (args.length > 0) {
+    lookupAndCallWorkerThatCallsIsolateExit(4);
+    print('got back');
+    return;
+  }
+  ProcessResult result = await Process.run(
+      Platform.executable, <String>[Platform.script.toString(), 'worker']);
+  Expect.isTrue(result.exitCode != 0);
+  // The child process should be terminated before it had a chance
+  // to print "got back".
+  Expect.isFalse(result.stdout.contains('got back'));
+}
diff --git a/runtime/vm/class_finalizer.cc b/runtime/vm/class_finalizer.cc
index f4d01aa..9326873 100644
--- a/runtime/vm/class_finalizer.cc
+++ b/runtime/vm/class_finalizer.cc
@@ -1226,15 +1226,16 @@
 
   const auto& values_field =
       Field::Handle(zone, enum_cls.LookupStaticField(Symbols::Values()));
-  ASSERT(!values_field.IsNull() && values_field.is_static() &&
-         values_field.is_const());
+  if (!values_field.IsNull()) {
+    ASSERT(values_field.is_static() && values_field.is_const());
 
-  const auto& values =
-      Object::Handle(zone, values_field.StaticConstFieldValue());
-  if (values.IsError()) {
-    ReportError(Error::Cast(values));
+    const auto& values =
+        Object::Handle(zone, values_field.StaticConstFieldValue());
+    if (values.IsError()) {
+      ReportError(Error::Cast(values));
+    }
+    ASSERT(values.IsArray());
   }
-  ASSERT(values.IsArray());
 
   // The enum_cls is the actual declared class.
   // The shared super-class holds the fields for index and name.
diff --git a/runtime/vm/compiler/assembler/assembler_arm.cc b/runtime/vm/compiler/assembler/assembler_arm.cc
index 8d265de..3aeae48 100644
--- a/runtime/vm/compiler/assembler/assembler_arm.cc
+++ b/runtime/vm/compiler/assembler/assembler_arm.cc
@@ -622,7 +622,9 @@
   }
 }
 
-void Assembler::ExitFullSafepoint(Register tmp1, Register tmp2) {
+void Assembler::ExitFullSafepoint(Register tmp1,
+                                  Register tmp2,
+                                  bool ignore_unwind_in_progress) {
   Register addr = tmp1;
   Register state = tmp2;
 
@@ -650,7 +652,14 @@
   }
 
   Bind(&slow_path);
-  ldr(TMP, Address(THR, target::Thread::exit_safepoint_stub_offset()));
+  if (ignore_unwind_in_progress) {
+    ldr(TMP,
+        Address(THR,
+                target::Thread::
+                    exit_safepoint_ignore_unwind_in_progress_stub_offset()));
+  } else {
+    ldr(TMP, Address(THR, target::Thread::exit_safepoint_stub_offset()));
+  }
   ldr(TMP, FieldAddress(TMP, target::Code::entry_point_offset()));
   blx(TMP);
 
@@ -659,10 +668,13 @@
 
 void Assembler::TransitionNativeToGenerated(Register addr,
                                             Register state,
-                                            bool exit_safepoint) {
+                                            bool exit_safepoint,
+                                            bool ignore_unwind_in_progress) {
   if (exit_safepoint) {
-    ExitFullSafepoint(addr, state);
+    ExitFullSafepoint(addr, state, ignore_unwind_in_progress);
   } else {
+    // flag only makes sense if we are leaving safepoint
+    ASSERT(!ignore_unwind_in_progress);
 #if defined(DEBUG)
     // Ensure we've already left the safepoint.
     ASSERT(target::Thread::full_safepoint_state_acquired() != 0);
diff --git a/runtime/vm/compiler/assembler/assembler_arm.h b/runtime/vm/compiler/assembler/assembler_arm.h
index 457b1da..c7168c3 100644
--- a/runtime/vm/compiler/assembler/assembler_arm.h
+++ b/runtime/vm/compiler/assembler/assembler_arm.h
@@ -614,9 +614,12 @@
                                    bool enter_safepoint);
   void TransitionNativeToGenerated(Register scratch0,
                                    Register scratch1,
-                                   bool exit_safepoint);
+                                   bool exit_safepoint,
+                                   bool ignore_unwind_in_progress = false);
   void EnterFullSafepoint(Register scratch0, Register scratch1);
-  void ExitFullSafepoint(Register scratch0, Register scratch1);
+  void ExitFullSafepoint(Register scratch0,
+                         Register scratch1,
+                         bool ignore_unwind_in_progress);
 
   // Miscellaneous instructions.
   void clrex();
diff --git a/runtime/vm/compiler/assembler/assembler_arm64.cc b/runtime/vm/compiler/assembler/assembler_arm64.cc
index 07bcb13..5869617 100644
--- a/runtime/vm/compiler/assembler/assembler_arm64.cc
+++ b/runtime/vm/compiler/assembler/assembler_arm64.cc
@@ -1735,7 +1735,8 @@
   }
 }
 
-void Assembler::ExitFullSafepoint(Register state) {
+void Assembler::ExitFullSafepoint(Register state,
+                                  bool ignore_unwind_in_progress) {
   // We generate the same number of instructions whether or not the slow-path is
   // forced, for consistency with EnterFullSafepoint.
   Register addr = TMP2;
@@ -1762,7 +1763,14 @@
   }
 
   Bind(&slow_path);
-  ldr(addr, Address(THR, target::Thread::exit_safepoint_stub_offset()));
+  if (ignore_unwind_in_progress) {
+    ldr(addr,
+        Address(THR,
+                target::Thread::
+                    exit_safepoint_ignore_unwind_in_progress_stub_offset()));
+  } else {
+    ldr(addr, Address(THR, target::Thread::exit_safepoint_stub_offset()));
+  }
   ldr(addr, FieldAddress(addr, target::Code::entry_point_offset()));
   blr(addr);
 
@@ -1770,10 +1778,13 @@
 }
 
 void Assembler::TransitionNativeToGenerated(Register state,
-                                            bool exit_safepoint) {
+                                            bool exit_safepoint,
+                                            bool ignore_unwind_in_progress) {
   if (exit_safepoint) {
-    ExitFullSafepoint(state);
+    ExitFullSafepoint(state, ignore_unwind_in_progress);
   } else {
+    // flag only makes sense if we are leaving safepoint
+    ASSERT(!ignore_unwind_in_progress);
 #if defined(DEBUG)
     // Ensure we've already left the safepoint.
     ASSERT(target::Thread::full_safepoint_state_acquired() != 0);
diff --git a/runtime/vm/compiler/assembler/assembler_arm64.h b/runtime/vm/compiler/assembler/assembler_arm64.h
index 554f4d8..e404453 100644
--- a/runtime/vm/compiler/assembler/assembler_arm64.h
+++ b/runtime/vm/compiler/assembler/assembler_arm64.h
@@ -2054,9 +2054,11 @@
                                    Register new_exit_frame,
                                    Register new_exit_through_ffi,
                                    bool enter_safepoint);
-  void TransitionNativeToGenerated(Register scratch, bool exit_safepoint);
+  void TransitionNativeToGenerated(Register scratch,
+                                   bool exit_safepoint,
+                                   bool ignore_unwind_in_progress = false);
   void EnterFullSafepoint(Register scratch);
-  void ExitFullSafepoint(Register scratch);
+  void ExitFullSafepoint(Register scratch, bool ignore_unwind_in_progress);
 
   void CheckCodePointer();
   void RestoreCodePointer();
diff --git a/runtime/vm/compiler/assembler/assembler_ia32.cc b/runtime/vm/compiler/assembler/assembler_ia32.cc
index 459cbf2..a3b12b0 100644
--- a/runtime/vm/compiler/assembler/assembler_ia32.cc
+++ b/runtime/vm/compiler/assembler/assembler_ia32.cc
@@ -2361,7 +2361,8 @@
   }
 }
 
-void Assembler::ExitFullSafepoint(Register scratch) {
+void Assembler::ExitFullSafepoint(Register scratch,
+                                  bool ignore_unwind_in_progress) {
   ASSERT(scratch != EAX);
   // We generate the same number of instructions whether or not the slow-path is
   // forced, for consistency with EnterFullSafepoint.
@@ -2386,7 +2387,14 @@
   }
 
   Bind(&slow_path);
-  movl(scratch, Address(THR, target::Thread::exit_safepoint_stub_offset()));
+  if (ignore_unwind_in_progress) {
+    movl(scratch,
+         Address(THR,
+                 target::Thread::
+                     exit_safepoint_ignore_unwind_in_progress_stub_offset()));
+  } else {
+    movl(scratch, Address(THR, target::Thread::exit_safepoint_stub_offset()));
+  }
   movl(scratch, FieldAddress(scratch, target::Code::entry_point_offset()));
   call(scratch);
 
@@ -2394,10 +2402,13 @@
 }
 
 void Assembler::TransitionNativeToGenerated(Register scratch,
-                                            bool exit_safepoint) {
+                                            bool exit_safepoint,
+                                            bool ignore_unwind_in_progress) {
   if (exit_safepoint) {
-    ExitFullSafepoint(scratch);
+    ExitFullSafepoint(scratch, ignore_unwind_in_progress);
   } else {
+    // flag only makes sense if we are leaving safepoint
+    ASSERT(!ignore_unwind_in_progress);
 #if defined(DEBUG)
     // Ensure we've already left the safepoint.
     movl(scratch, Address(THR, target::Thread::safepoint_state_offset()));
diff --git a/runtime/vm/compiler/assembler/assembler_ia32.h b/runtime/vm/compiler/assembler/assembler_ia32.h
index e5b2b1a..d5b61ee 100644
--- a/runtime/vm/compiler/assembler/assembler_ia32.h
+++ b/runtime/vm/compiler/assembler/assembler_ia32.h
@@ -819,9 +819,11 @@
                                    Register new_exit_frame,
                                    Register new_exit_through_ffi,
                                    bool enter_safepoint);
-  void TransitionNativeToGenerated(Register scratch, bool exit_safepoint);
+  void TransitionNativeToGenerated(Register scratch,
+                                   bool exit_safepoint,
+                                   bool ignore_unwind_in_progress = false);
   void EnterFullSafepoint(Register scratch);
-  void ExitFullSafepoint(Register scratch);
+  void ExitFullSafepoint(Register scratch, bool ignore_unwind_in_progress);
 
   // Create a frame for calling into runtime that preserves all volatile
   // registers.  Frame's RSP is guaranteed to be correctly aligned and
diff --git a/runtime/vm/compiler/assembler/assembler_x64.cc b/runtime/vm/compiler/assembler/assembler_x64.cc
index 12398f9..a72850f 100644
--- a/runtime/vm/compiler/assembler/assembler_x64.cc
+++ b/runtime/vm/compiler/assembler/assembler_x64.cc
@@ -184,7 +184,7 @@
   }
 }
 
-void Assembler::ExitFullSafepoint() {
+void Assembler::ExitFullSafepoint(bool ignore_unwind_in_progress) {
   // We generate the same number of instructions whether or not the slow-path is
   // forced, for consistency with EnterFullSafepoint.
   Label done, slow_path;
@@ -209,7 +209,14 @@
   }
 
   Bind(&slow_path);
-  movq(TMP, Address(THR, target::Thread::exit_safepoint_stub_offset()));
+  if (ignore_unwind_in_progress) {
+    movq(TMP,
+         Address(THR,
+                 target::Thread::
+                     exit_safepoint_ignore_unwind_in_progress_stub_offset()));
+  } else {
+    movq(TMP, Address(THR, target::Thread::exit_safepoint_stub_offset()));
+  }
   movq(TMP, FieldAddress(TMP, target::Code::entry_point_offset()));
 
   // Use call instead of CallCFunction to avoid having to clean up shadow space
@@ -220,10 +227,13 @@
   Bind(&done);
 }
 
-void Assembler::TransitionNativeToGenerated(bool leave_safepoint) {
+void Assembler::TransitionNativeToGenerated(bool leave_safepoint,
+                                            bool ignore_unwind_in_progress) {
   if (leave_safepoint) {
-    ExitFullSafepoint();
+    ExitFullSafepoint(ignore_unwind_in_progress);
   } else {
+    // flag only makes sense if we are leaving safepoint
+    ASSERT(!ignore_unwind_in_progress);
 #if defined(DEBUG)
     // Ensure we've already left the safepoint.
     movq(TMP, Address(THR, target::Thread::safepoint_state_offset()));
diff --git a/runtime/vm/compiler/assembler/assembler_x64.h b/runtime/vm/compiler/assembler/assembler_x64.h
index 3f4bf92..dd5882c 100644
--- a/runtime/vm/compiler/assembler/assembler_x64.h
+++ b/runtime/vm/compiler/assembler/assembler_x64.h
@@ -319,12 +319,13 @@
   void setcc(Condition condition, ByteRegister dst);
 
   void EnterFullSafepoint();
-  void ExitFullSafepoint();
+  void ExitFullSafepoint(bool ignore_unwind_in_progress);
   void TransitionGeneratedToNative(Register destination_address,
                                    Register new_exit_frame,
                                    Register new_exit_through_ffi,
                                    bool enter_safepoint);
-  void TransitionNativeToGenerated(bool leave_safepoint);
+  void TransitionNativeToGenerated(bool leave_safepoint,
+                                   bool ignore_unwind_in_progress = false);
 
 // Register-register, register-address and address-register instructions.
 #define RR(width, name, ...)                                                   \
diff --git a/runtime/vm/compiler/assembler/assembler_x64_test.cc b/runtime/vm/compiler/assembler/assembler_x64_test.cc
index 1dded0f..761a858 100644
--- a/runtime/vm/compiler/assembler/assembler_x64_test.cc
+++ b/runtime/vm/compiler/assembler/assembler_x64_test.cc
@@ -3384,7 +3384,7 @@
   EXPECT_FLOAT_EQ(-1.0, res, 0.000001f);
   EXPECT_DISASSEMBLY_NOT_WINDOWS_ENDS_WITH(
       "movups xmm10,[rax]\n"
-      "movq r11,[thr+0x2b0]\n"
+      "movq r11,[thr+0x...]\n"
       "xorpd xmm10,[r11]\n"
       "movaps xmm0,xmm10\n"
       "pop thr\n"
@@ -3413,7 +3413,7 @@
   EXPECT_FLOAT_EQ(1.0, res, 0.000001f);
   EXPECT_DISASSEMBLY_NOT_WINDOWS_ENDS_WITH(
       "movups xmm10,[rax]\n"
-      "movq r11,[thr+0x2b8]\n"
+      "movq r11,[thr+0x...]\n"
       "movups xmm0,[r11]\n"
       "andpd xmm0,xmm10\n"
       "pop thr\n"
@@ -4066,7 +4066,7 @@
       "movl rax,0x4144cccd\n"
       "movd xmm0,rax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "movq r11,[thr+0x2c8]\n"
+      "movq r11,[thr+0x...]\n"
       "xorps xmm0,[r11]\n"
       "shufps xmm0,xmm0 [aa]\n"
       "pop thr\n"
@@ -4103,7 +4103,7 @@
       "movl rax,-0x3e8b3333\n"
       "movd xmm0,rax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "movq r11,[thr+0x2d0]\n"
+      "movq r11,[thr+0x...]\n"
       "andps xmm0,[r11]\n"
       "shufps xmm0,xmm0 [aa]\n"
       "pop thr\n"
@@ -4138,7 +4138,7 @@
       "movl rax,0x4144cccd\n"
       "movd xmm0,rax\n"
       "shufps xmm0,xmm0 [0]\n"
-      "movq r11,[thr+0x2d8]\n"
+      "movq r11,[thr+0x...]\n"
       "andps xmm0,[r11]\n"
       "shufps xmm0,xmm0 [ff]\n"
       "pop thr\n"
@@ -4288,7 +4288,7 @@
   EXPECT_EQ(static_cast<uword>(0x0), res);
   EXPECT_DISASSEMBLY_NOT_WINDOWS_ENDS_WITH(
       "movups xmm9,[rax]\n"
-      "movq r11,[thr+0x2c0]\n"
+      "movq r11,[thr+0x...]\n"
       "movups xmm0,[r11]\n"
       "xorps xmm0,xmm9\n"
       "push rax\n"
@@ -5464,7 +5464,7 @@
       "movq r12,[rdi+0x8]\n"
       "movq thr,rsi\n"
       "movq pp,[r12+0x27]\n"
-      "movq r11,[thr+0x2b8]\n"
+      "movq r11,[thr+0x...]\n"
       "andpd xmm0,[r11]\n"
       "pop thr\n"
       "pop pp\n"
diff --git a/runtime/vm/compiler/runtime_api.h b/runtime/vm/compiler/runtime_api.h
index c7fd307..0559b8c 100644
--- a/runtime/vm/compiler/runtime_api.h
+++ b/runtime/vm/compiler/runtime_api.h
@@ -1176,6 +1176,7 @@
   static word deoptimize_stub_offset();
   static word enter_safepoint_stub_offset();
   static word exit_safepoint_stub_offset();
+  static word exit_safepoint_ignore_unwind_in_progress_stub_offset();
   static word call_native_through_safepoint_stub_offset();
   static word call_native_through_safepoint_entry_point_offset();
 
diff --git a/runtime/vm/compiler/runtime_offsets_extracted.h b/runtime/vm/compiler/runtime_offsets_extracted.h
index 5d764cf..4784b36 100644
--- a/runtime/vm/compiler/runtime_offsets_extracted.h
+++ b/runtime/vm/compiler/runtime_offsets_extracted.h
@@ -242,93 +242,95 @@
 static constexpr dart::compiler::target::word String_length_offset = 4;
 static constexpr dart::compiler::target::word SubtypeTestCache_cache_offset = 4;
 static constexpr dart::compiler::target::word
-    Thread_AllocateArray_entry_point_offset = 380;
+    Thread_AllocateArray_entry_point_offset = 384;
 static constexpr dart::compiler::target::word Thread_active_exception_offset =
-    752;
+    760;
 static constexpr dart::compiler::target::word Thread_active_stacktrace_offset =
-    756;
+    764;
 static constexpr dart::compiler::target::word
     Thread_array_write_barrier_code_offset = 128;
 static constexpr dart::compiler::target::word
-    Thread_array_write_barrier_entry_point_offset = 272;
+    Thread_array_write_barrier_entry_point_offset = 276;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 280;
+    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 284;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_with_fpu_regs_stub_offset = 188;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 284;
+    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 288;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_without_fpu_regs_stub_offset = 192;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_entry_point_offset = 288;
+    Thread_allocate_object_entry_point_offset = 292;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_stub_offset = 196;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_parameterized_entry_point_offset = 292;
+    Thread_allocate_object_parameterized_entry_point_offset = 296;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_parameterized_stub_offset = 200;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_slow_entry_point_offset = 296;
+    Thread_allocate_object_slow_entry_point_offset = 300;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_slow_stub_offset = 204;
-static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 792;
+static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 800;
 static constexpr dart::compiler::target::word
-    Thread_auto_scope_native_wrapper_entry_point_offset = 344;
+    Thread_auto_scope_native_wrapper_entry_point_offset = 348;
 static constexpr dart::compiler::target::word Thread_bool_false_offset = 120;
 static constexpr dart::compiler::target::word Thread_bool_true_offset = 116;
 static constexpr dart::compiler::target::word
-    Thread_bootstrap_native_wrapper_entry_point_offset = 336;
+    Thread_bootstrap_native_wrapper_entry_point_offset = 340;
 static constexpr dart::compiler::target::word
-    Thread_call_to_runtime_entry_point_offset = 276;
+    Thread_call_to_runtime_entry_point_offset = 280;
 static constexpr dart::compiler::target::word
     Thread_call_to_runtime_stub_offset = 144;
-static constexpr dart::compiler::target::word Thread_dart_stream_offset = 816;
+static constexpr dart::compiler::target::word Thread_dart_stream_offset = 824;
 static constexpr dart::compiler::target::word
     Thread_dispatch_table_array_offset = 44;
 static constexpr dart::compiler::target::word
-    Thread_double_truncate_round_supported_offset = 796;
+    Thread_double_truncate_round_supported_offset = 804;
 static constexpr dart::compiler::target::word Thread_optimize_entry_offset =
-    316;
+    320;
 static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 232;
 static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset =
-    320;
+    324;
 static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset =
     236;
 static constexpr dart::compiler::target::word Thread_double_abs_address_offset =
-    360;
+    364;
 static constexpr dart::compiler::target::word
-    Thread_double_negate_address_offset = 356;
+    Thread_double_negate_address_offset = 360;
 static constexpr dart::compiler::target::word Thread_end_offset = 52;
 static constexpr dart::compiler::target::word
     Thread_enter_safepoint_stub_offset = 256;
 static constexpr dart::compiler::target::word Thread_execution_state_offset =
-    772;
+    780;
 static constexpr dart::compiler::target::word
     Thread_exit_safepoint_stub_offset = 260;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_stub_offset = 264;
+    Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 264;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_entry_point_offset = 324;
+    Thread_call_native_through_safepoint_stub_offset = 268;
+static constexpr dart::compiler::target::word
+    Thread_call_native_through_safepoint_entry_point_offset = 328;
 static constexpr dart::compiler::target::word
     Thread_fix_allocation_stub_code_offset = 136;
 static constexpr dart::compiler::target::word
     Thread_fix_callers_target_code_offset = 132;
 static constexpr dart::compiler::target::word
-    Thread_float_absolute_address_offset = 372;
+    Thread_float_absolute_address_offset = 376;
 static constexpr dart::compiler::target::word
-    Thread_float_negate_address_offset = 368;
+    Thread_float_negate_address_offset = 372;
 static constexpr dart::compiler::target::word Thread_float_not_address_offset =
-    364;
+    368;
 static constexpr dart::compiler::target::word
-    Thread_float_zerow_address_offset = 376;
+    Thread_float_zerow_address_offset = 380;
 static constexpr dart::compiler::target::word Thread_global_object_pool_offset =
-    760;
+    768;
 static constexpr dart::compiler::target::word
     Thread_invoke_dart_code_stub_offset = 140;
 static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset =
-    788;
+    796;
 static constexpr dart::compiler::target::word Thread_isolate_offset = 40;
-static constexpr dart::compiler::target::word Thread_isolate_group_offset = 820;
+static constexpr dart::compiler::target::word Thread_isolate_group_offset = 828;
 static constexpr dart::compiler::target::word Thread_field_table_values_offset =
     64;
 static constexpr dart::compiler::target::word
@@ -340,13 +342,13 @@
 static constexpr dart::compiler::target::word
     Thread_marking_stack_block_offset = 80;
 static constexpr dart::compiler::target::word
-    Thread_megamorphic_call_checked_entry_offset = 308;
+    Thread_megamorphic_call_checked_entry_offset = 312;
 static constexpr dart::compiler::target::word
-    Thread_switchable_call_miss_entry_offset = 312;
+    Thread_switchable_call_miss_entry_offset = 316;
 static constexpr dart::compiler::target::word
     Thread_switchable_call_miss_stub_offset = 216;
 static constexpr dart::compiler::target::word
-    Thread_no_scope_native_wrapper_entry_point_offset = 340;
+    Thread_no_scope_native_wrapper_entry_point_offset = 344;
 static constexpr dart::compiler::target::word
     Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 152;
 static constexpr dart::compiler::target::word
@@ -369,27 +371,27 @@
     Thread_range_error_shared_without_fpu_regs_stub_offset = 180;
 static constexpr dart::compiler::target::word Thread_object_null_offset = 112;
 static constexpr dart::compiler::target::word
-    Thread_predefined_symbols_address_offset = 348;
-static constexpr dart::compiler::target::word Thread_resume_pc_offset = 764;
+    Thread_predefined_symbols_address_offset = 352;
+static constexpr dart::compiler::target::word Thread_resume_pc_offset = 772;
 static constexpr dart::compiler::target::word
-    Thread_saved_shadow_call_stack_offset = 768;
+    Thread_saved_shadow_call_stack_offset = 776;
 static constexpr dart::compiler::target::word Thread_safepoint_state_offset =
-    776;
+    784;
 static constexpr dart::compiler::target::word
     Thread_slow_type_test_stub_offset = 248;
 static constexpr dart::compiler::target::word
-    Thread_slow_type_test_entry_point_offset = 332;
+    Thread_slow_type_test_entry_point_offset = 336;
 static constexpr dart::compiler::target::word Thread_stack_limit_offset = 28;
 static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset =
     56;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_flags_offset = 60;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 304;
+    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 308;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 212;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 300;
+    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 304;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 208;
 static constexpr dart::compiler::target::word Thread_store_buffer_block_offset =
@@ -406,17 +408,17 @@
 static constexpr dart::compiler::target::word Thread_write_barrier_code_offset =
     124;
 static constexpr dart::compiler::target::word
-    Thread_write_barrier_entry_point_offset = 268;
+    Thread_write_barrier_entry_point_offset = 272;
 static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset =
     32;
 static constexpr dart::compiler::target::word Thread_heap_base_offset = 36;
-static constexpr dart::compiler::target::word Thread_callback_code_offset = 780;
+static constexpr dart::compiler::target::word Thread_callback_code_offset = 788;
 static constexpr dart::compiler::target::word
-    Thread_callback_stack_return_offset = 784;
-static constexpr dart::compiler::target::word Thread_random_offset = 800;
+    Thread_callback_stack_return_offset = 792;
+static constexpr dart::compiler::target::word Thread_random_offset = 808;
 static constexpr dart::compiler::target::word
-    Thread_jump_to_frame_entry_point_offset = 328;
-static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 808;
+    Thread_jump_to_frame_entry_point_offset = 332;
+static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 816;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset =
     0;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset =
@@ -485,7 +487,7 @@
     4, 12, 8, 16};
 static constexpr dart::compiler::target::word
     Thread_write_barrier_wrappers_thread_offset[] = {
-        720, 724, 728, 732, 736, -1, 740, -1, 744, 748, -1, -1, -1, -1, -1, -1};
+        728, 732, 736, 740, 744, -1, 748, -1, 752, 756, -1, -1, -1, -1, -1, -1};
 static constexpr dart::compiler::target::word AbstractType_InstanceSize = 12;
 static constexpr dart::compiler::target::word ApiError_InstanceSize = 8;
 static constexpr dart::compiler::target::word Array_header_size = 12;
@@ -807,95 +809,97 @@
 static constexpr dart::compiler::target::word String_length_offset = 8;
 static constexpr dart::compiler::target::word SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    Thread_AllocateArray_entry_point_offset = 736;
+    Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word Thread_active_exception_offset =
-    1504;
+    1520;
 static constexpr dart::compiler::target::word Thread_active_stacktrace_offset =
-    1512;
+    1528;
 static constexpr dart::compiler::target::word
     Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    Thread_array_write_barrier_entry_point_offset = 520;
+    Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_entry_point_offset = 552;
+    Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_parameterized_entry_point_offset = 560;
+    Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_slow_entry_point_offset = 568;
+    Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word Thread_api_top_scope_offset =
-    1584;
+    1600;
 static constexpr dart::compiler::target::word
-    Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word Thread_bool_false_offset = 216;
 static constexpr dart::compiler::target::word Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    Thread_call_to_runtime_entry_point_offset = 528;
+    Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     Thread_call_to_runtime_stub_offset = 264;
-static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1624;
+static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1640;
 static constexpr dart::compiler::target::word
     Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    Thread_double_truncate_round_supported_offset = 1592;
+    Thread_double_truncate_round_supported_offset = 1608;
 static constexpr dart::compiler::target::word Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 440;
 static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset =
-    616;
+    624;
 static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset =
     448;
 static constexpr dart::compiler::target::word Thread_double_abs_address_offset =
-    696;
+    704;
 static constexpr dart::compiler::target::word
-    Thread_double_negate_address_offset = 688;
+    Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word Thread_execution_state_offset =
-    1544;
+    1560;
 static constexpr dart::compiler::target::word
     Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_stub_offset = 504;
+    Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_entry_point_offset = 624;
+    Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    Thread_float_absolute_address_offset = 720;
+    Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    Thread_float_negate_address_offset = 712;
+    Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word Thread_float_not_address_offset =
-    704;
+    712;
 static constexpr dart::compiler::target::word
-    Thread_float_zerow_address_offset = 728;
+    Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word Thread_global_object_pool_offset =
-    1520;
+    1536;
 static constexpr dart::compiler::target::word
     Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset =
-    1576;
+    1592;
 static constexpr dart::compiler::target::word Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word Thread_isolate_group_offset =
-    1632;
+    1648;
 static constexpr dart::compiler::target::word Thread_field_table_values_offset =
     128;
 static constexpr dart::compiler::target::word
@@ -907,13 +911,13 @@
 static constexpr dart::compiler::target::word
     Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    Thread_megamorphic_call_checked_entry_offset = 592;
+    Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    Thread_switchable_call_miss_entry_offset = 600;
+    Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -936,27 +940,27 @@
     Thread_range_error_shared_without_fpu_regs_stub_offset = 336;
 static constexpr dart::compiler::target::word Thread_object_null_offset = 200;
 static constexpr dart::compiler::target::word
-    Thread_predefined_symbols_address_offset = 672;
-static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1528;
+    Thread_predefined_symbols_address_offset = 680;
+static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1544;
 static constexpr dart::compiler::target::word
-    Thread_saved_shadow_call_stack_offset = 1536;
+    Thread_saved_shadow_call_stack_offset = 1552;
 static constexpr dart::compiler::target::word Thread_safepoint_state_offset =
-    1552;
+    1568;
 static constexpr dart::compiler::target::word
     Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    Thread_slow_type_test_entry_point_offset = 640;
+    Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word Thread_stack_limit_offset = 56;
 static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset =
     112;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word Thread_store_buffer_block_offset =
@@ -973,18 +977,18 @@
 static constexpr dart::compiler::target::word Thread_write_barrier_code_offset =
     224;
 static constexpr dart::compiler::target::word
-    Thread_write_barrier_entry_point_offset = 512;
+    Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset =
     64;
 static constexpr dart::compiler::target::word Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word Thread_callback_code_offset =
-    1560;
+    1576;
 static constexpr dart::compiler::target::word
-    Thread_callback_stack_return_offset = 1568;
-static constexpr dart::compiler::target::word Thread_random_offset = 1600;
+    Thread_callback_stack_return_offset = 1584;
+static constexpr dart::compiler::target::word Thread_random_offset = 1616;
 static constexpr dart::compiler::target::word
-    Thread_jump_to_frame_entry_point_offset = 632;
-static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1608;
+    Thread_jump_to_frame_entry_point_offset = 640;
+static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1624;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset =
     0;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset =
@@ -1055,8 +1059,8 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, -1,   -1,   1448, 1456,
-        1464, 1472, 1480, -1,   1488, 1496, -1,   -1};
+        1432, 1440, 1448, 1456, -1,   -1,   1464, 1472,
+        1480, 1488, 1496, -1,   1504, 1512, -1,   -1};
 static constexpr dart::compiler::target::word AbstractType_InstanceSize = 24;
 static constexpr dart::compiler::target::word ApiError_InstanceSize = 16;
 static constexpr dart::compiler::target::word Array_header_size = 24;
@@ -1374,93 +1378,95 @@
 static constexpr dart::compiler::target::word String_length_offset = 4;
 static constexpr dart::compiler::target::word SubtypeTestCache_cache_offset = 4;
 static constexpr dart::compiler::target::word
-    Thread_AllocateArray_entry_point_offset = 380;
+    Thread_AllocateArray_entry_point_offset = 384;
 static constexpr dart::compiler::target::word Thread_active_exception_offset =
-    720;
+    728;
 static constexpr dart::compiler::target::word Thread_active_stacktrace_offset =
-    724;
+    732;
 static constexpr dart::compiler::target::word
     Thread_array_write_barrier_code_offset = 128;
 static constexpr dart::compiler::target::word
-    Thread_array_write_barrier_entry_point_offset = 272;
+    Thread_array_write_barrier_entry_point_offset = 276;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 280;
+    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 284;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_with_fpu_regs_stub_offset = 188;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 284;
+    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 288;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_without_fpu_regs_stub_offset = 192;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_entry_point_offset = 288;
+    Thread_allocate_object_entry_point_offset = 292;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_stub_offset = 196;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_parameterized_entry_point_offset = 292;
+    Thread_allocate_object_parameterized_entry_point_offset = 296;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_parameterized_stub_offset = 200;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_slow_entry_point_offset = 296;
+    Thread_allocate_object_slow_entry_point_offset = 300;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_slow_stub_offset = 204;
-static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 760;
+static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 768;
 static constexpr dart::compiler::target::word
-    Thread_auto_scope_native_wrapper_entry_point_offset = 344;
+    Thread_auto_scope_native_wrapper_entry_point_offset = 348;
 static constexpr dart::compiler::target::word Thread_bool_false_offset = 120;
 static constexpr dart::compiler::target::word Thread_bool_true_offset = 116;
 static constexpr dart::compiler::target::word
-    Thread_bootstrap_native_wrapper_entry_point_offset = 336;
+    Thread_bootstrap_native_wrapper_entry_point_offset = 340;
 static constexpr dart::compiler::target::word
-    Thread_call_to_runtime_entry_point_offset = 276;
+    Thread_call_to_runtime_entry_point_offset = 280;
 static constexpr dart::compiler::target::word
     Thread_call_to_runtime_stub_offset = 144;
-static constexpr dart::compiler::target::word Thread_dart_stream_offset = 784;
+static constexpr dart::compiler::target::word Thread_dart_stream_offset = 792;
 static constexpr dart::compiler::target::word
     Thread_dispatch_table_array_offset = 44;
 static constexpr dart::compiler::target::word
-    Thread_double_truncate_round_supported_offset = 764;
+    Thread_double_truncate_round_supported_offset = 772;
 static constexpr dart::compiler::target::word Thread_optimize_entry_offset =
-    316;
+    320;
 static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 232;
 static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset =
-    320;
+    324;
 static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset =
     236;
 static constexpr dart::compiler::target::word Thread_double_abs_address_offset =
-    360;
+    364;
 static constexpr dart::compiler::target::word
-    Thread_double_negate_address_offset = 356;
+    Thread_double_negate_address_offset = 360;
 static constexpr dart::compiler::target::word Thread_end_offset = 52;
 static constexpr dart::compiler::target::word
     Thread_enter_safepoint_stub_offset = 256;
 static constexpr dart::compiler::target::word Thread_execution_state_offset =
-    740;
+    748;
 static constexpr dart::compiler::target::word
     Thread_exit_safepoint_stub_offset = 260;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_stub_offset = 264;
+    Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 264;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_entry_point_offset = 324;
+    Thread_call_native_through_safepoint_stub_offset = 268;
+static constexpr dart::compiler::target::word
+    Thread_call_native_through_safepoint_entry_point_offset = 328;
 static constexpr dart::compiler::target::word
     Thread_fix_allocation_stub_code_offset = 136;
 static constexpr dart::compiler::target::word
     Thread_fix_callers_target_code_offset = 132;
 static constexpr dart::compiler::target::word
-    Thread_float_absolute_address_offset = 372;
+    Thread_float_absolute_address_offset = 376;
 static constexpr dart::compiler::target::word
-    Thread_float_negate_address_offset = 368;
+    Thread_float_negate_address_offset = 372;
 static constexpr dart::compiler::target::word Thread_float_not_address_offset =
-    364;
+    368;
 static constexpr dart::compiler::target::word
-    Thread_float_zerow_address_offset = 376;
+    Thread_float_zerow_address_offset = 380;
 static constexpr dart::compiler::target::word Thread_global_object_pool_offset =
-    728;
+    736;
 static constexpr dart::compiler::target::word
     Thread_invoke_dart_code_stub_offset = 140;
 static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset =
-    756;
+    764;
 static constexpr dart::compiler::target::word Thread_isolate_offset = 40;
-static constexpr dart::compiler::target::word Thread_isolate_group_offset = 788;
+static constexpr dart::compiler::target::word Thread_isolate_group_offset = 796;
 static constexpr dart::compiler::target::word Thread_field_table_values_offset =
     64;
 static constexpr dart::compiler::target::word
@@ -1472,13 +1478,13 @@
 static constexpr dart::compiler::target::word
     Thread_marking_stack_block_offset = 80;
 static constexpr dart::compiler::target::word
-    Thread_megamorphic_call_checked_entry_offset = 308;
+    Thread_megamorphic_call_checked_entry_offset = 312;
 static constexpr dart::compiler::target::word
-    Thread_switchable_call_miss_entry_offset = 312;
+    Thread_switchable_call_miss_entry_offset = 316;
 static constexpr dart::compiler::target::word
     Thread_switchable_call_miss_stub_offset = 216;
 static constexpr dart::compiler::target::word
-    Thread_no_scope_native_wrapper_entry_point_offset = 340;
+    Thread_no_scope_native_wrapper_entry_point_offset = 344;
 static constexpr dart::compiler::target::word
     Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 152;
 static constexpr dart::compiler::target::word
@@ -1501,27 +1507,27 @@
     Thread_range_error_shared_without_fpu_regs_stub_offset = 180;
 static constexpr dart::compiler::target::word Thread_object_null_offset = 112;
 static constexpr dart::compiler::target::word
-    Thread_predefined_symbols_address_offset = 348;
-static constexpr dart::compiler::target::word Thread_resume_pc_offset = 732;
+    Thread_predefined_symbols_address_offset = 352;
+static constexpr dart::compiler::target::word Thread_resume_pc_offset = 740;
 static constexpr dart::compiler::target::word
-    Thread_saved_shadow_call_stack_offset = 736;
+    Thread_saved_shadow_call_stack_offset = 744;
 static constexpr dart::compiler::target::word Thread_safepoint_state_offset =
-    744;
+    752;
 static constexpr dart::compiler::target::word
     Thread_slow_type_test_stub_offset = 248;
 static constexpr dart::compiler::target::word
-    Thread_slow_type_test_entry_point_offset = 332;
+    Thread_slow_type_test_entry_point_offset = 336;
 static constexpr dart::compiler::target::word Thread_stack_limit_offset = 28;
 static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset =
     56;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_flags_offset = 60;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 304;
+    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 308;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 212;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 300;
+    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 304;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 208;
 static constexpr dart::compiler::target::word Thread_store_buffer_block_offset =
@@ -1538,17 +1544,17 @@
 static constexpr dart::compiler::target::word Thread_write_barrier_code_offset =
     124;
 static constexpr dart::compiler::target::word
-    Thread_write_barrier_entry_point_offset = 268;
+    Thread_write_barrier_entry_point_offset = 272;
 static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset =
     32;
 static constexpr dart::compiler::target::word Thread_heap_base_offset = 36;
-static constexpr dart::compiler::target::word Thread_callback_code_offset = 748;
+static constexpr dart::compiler::target::word Thread_callback_code_offset = 756;
 static constexpr dart::compiler::target::word
-    Thread_callback_stack_return_offset = 752;
-static constexpr dart::compiler::target::word Thread_random_offset = 768;
+    Thread_callback_stack_return_offset = 760;
+static constexpr dart::compiler::target::word Thread_random_offset = 776;
 static constexpr dart::compiler::target::word
-    Thread_jump_to_frame_entry_point_offset = 328;
-static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 776;
+    Thread_jump_to_frame_entry_point_offset = 332;
+static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 784;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset =
     0;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset =
@@ -1936,95 +1942,97 @@
 static constexpr dart::compiler::target::word String_length_offset = 8;
 static constexpr dart::compiler::target::word SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    Thread_AllocateArray_entry_point_offset = 736;
+    Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word Thread_active_exception_offset =
-    1568;
+    1584;
 static constexpr dart::compiler::target::word Thread_active_stacktrace_offset =
-    1576;
+    1592;
 static constexpr dart::compiler::target::word
     Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    Thread_array_write_barrier_entry_point_offset = 520;
+    Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_entry_point_offset = 552;
+    Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_parameterized_entry_point_offset = 560;
+    Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_slow_entry_point_offset = 568;
+    Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word Thread_api_top_scope_offset =
-    1648;
+    1664;
 static constexpr dart::compiler::target::word
-    Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word Thread_bool_false_offset = 216;
 static constexpr dart::compiler::target::word Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    Thread_call_to_runtime_entry_point_offset = 528;
+    Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     Thread_call_to_runtime_stub_offset = 264;
-static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1688;
+static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1704;
 static constexpr dart::compiler::target::word
     Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    Thread_double_truncate_round_supported_offset = 1656;
+    Thread_double_truncate_round_supported_offset = 1672;
 static constexpr dart::compiler::target::word Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 440;
 static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset =
-    616;
+    624;
 static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset =
     448;
 static constexpr dart::compiler::target::word Thread_double_abs_address_offset =
-    696;
+    704;
 static constexpr dart::compiler::target::word
-    Thread_double_negate_address_offset = 688;
+    Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word Thread_execution_state_offset =
-    1608;
+    1624;
 static constexpr dart::compiler::target::word
     Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_stub_offset = 504;
+    Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_entry_point_offset = 624;
+    Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    Thread_float_absolute_address_offset = 720;
+    Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    Thread_float_negate_address_offset = 712;
+    Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word Thread_float_not_address_offset =
-    704;
+    712;
 static constexpr dart::compiler::target::word
-    Thread_float_zerow_address_offset = 728;
+    Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word Thread_global_object_pool_offset =
-    1584;
+    1600;
 static constexpr dart::compiler::target::word
     Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset =
-    1640;
+    1656;
 static constexpr dart::compiler::target::word Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word Thread_isolate_group_offset =
-    1696;
+    1712;
 static constexpr dart::compiler::target::word Thread_field_table_values_offset =
     128;
 static constexpr dart::compiler::target::word
@@ -2036,13 +2044,13 @@
 static constexpr dart::compiler::target::word
     Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    Thread_megamorphic_call_checked_entry_offset = 592;
+    Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    Thread_switchable_call_miss_entry_offset = 600;
+    Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -2065,27 +2073,27 @@
     Thread_range_error_shared_without_fpu_regs_stub_offset = 336;
 static constexpr dart::compiler::target::word Thread_object_null_offset = 200;
 static constexpr dart::compiler::target::word
-    Thread_predefined_symbols_address_offset = 672;
-static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1592;
+    Thread_predefined_symbols_address_offset = 680;
+static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1608;
 static constexpr dart::compiler::target::word
-    Thread_saved_shadow_call_stack_offset = 1600;
+    Thread_saved_shadow_call_stack_offset = 1616;
 static constexpr dart::compiler::target::word Thread_safepoint_state_offset =
-    1616;
+    1632;
 static constexpr dart::compiler::target::word
     Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    Thread_slow_type_test_entry_point_offset = 640;
+    Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word Thread_stack_limit_offset = 56;
 static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset =
     112;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word Thread_store_buffer_block_offset =
@@ -2102,18 +2110,18 @@
 static constexpr dart::compiler::target::word Thread_write_barrier_code_offset =
     224;
 static constexpr dart::compiler::target::word
-    Thread_write_barrier_entry_point_offset = 512;
+    Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset =
     64;
 static constexpr dart::compiler::target::word Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word Thread_callback_code_offset =
-    1624;
+    1640;
 static constexpr dart::compiler::target::word
-    Thread_callback_stack_return_offset = 1632;
-static constexpr dart::compiler::target::word Thread_random_offset = 1664;
+    Thread_callback_stack_return_offset = 1648;
+static constexpr dart::compiler::target::word Thread_random_offset = 1680;
 static constexpr dart::compiler::target::word
-    Thread_jump_to_frame_entry_point_offset = 632;
-static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1672;
+    Thread_jump_to_frame_entry_point_offset = 640;
+static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1688;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset =
     0;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset =
@@ -2184,9 +2192,9 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496,
-        1504, 1512, 1520, 1528, -1,   -1,   -1,   -1,   1536, 1544, -1,
-        -1,   1552, 1560, 1568, -1,   -1,   -1,   -1,   -1,   -1};
+        1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496, 1504, 1512,
+        1520, 1528, 1536, 1544, -1,   -1,   -1,   -1,   1552, 1560, -1,
+        -1,   1568, 1576, 1584, -1,   -1,   -1,   -1,   -1,   -1};
 static constexpr dart::compiler::target::word AbstractType_InstanceSize = 24;
 static constexpr dart::compiler::target::word ApiError_InstanceSize = 16;
 static constexpr dart::compiler::target::word Array_header_size = 24;
@@ -2506,95 +2514,97 @@
 static constexpr dart::compiler::target::word String_length_offset = 8;
 static constexpr dart::compiler::target::word SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    Thread_AllocateArray_entry_point_offset = 736;
+    Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word Thread_active_exception_offset =
-    1504;
+    1520;
 static constexpr dart::compiler::target::word Thread_active_stacktrace_offset =
-    1512;
+    1528;
 static constexpr dart::compiler::target::word
     Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    Thread_array_write_barrier_entry_point_offset = 520;
+    Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_entry_point_offset = 552;
+    Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_parameterized_entry_point_offset = 560;
+    Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_slow_entry_point_offset = 568;
+    Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word Thread_api_top_scope_offset =
-    1584;
+    1600;
 static constexpr dart::compiler::target::word
-    Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word Thread_bool_false_offset = 216;
 static constexpr dart::compiler::target::word Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    Thread_call_to_runtime_entry_point_offset = 528;
+    Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     Thread_call_to_runtime_stub_offset = 264;
-static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1624;
+static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1640;
 static constexpr dart::compiler::target::word
     Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    Thread_double_truncate_round_supported_offset = 1592;
+    Thread_double_truncate_round_supported_offset = 1608;
 static constexpr dart::compiler::target::word Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 440;
 static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset =
-    616;
+    624;
 static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset =
     448;
 static constexpr dart::compiler::target::word Thread_double_abs_address_offset =
-    696;
+    704;
 static constexpr dart::compiler::target::word
-    Thread_double_negate_address_offset = 688;
+    Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word Thread_execution_state_offset =
-    1544;
+    1560;
 static constexpr dart::compiler::target::word
     Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_stub_offset = 504;
+    Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_entry_point_offset = 624;
+    Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    Thread_float_absolute_address_offset = 720;
+    Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    Thread_float_negate_address_offset = 712;
+    Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word Thread_float_not_address_offset =
-    704;
+    712;
 static constexpr dart::compiler::target::word
-    Thread_float_zerow_address_offset = 728;
+    Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word Thread_global_object_pool_offset =
-    1520;
+    1536;
 static constexpr dart::compiler::target::word
     Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset =
-    1576;
+    1592;
 static constexpr dart::compiler::target::word Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word Thread_isolate_group_offset =
-    1632;
+    1648;
 static constexpr dart::compiler::target::word Thread_field_table_values_offset =
     128;
 static constexpr dart::compiler::target::word
@@ -2606,13 +2616,13 @@
 static constexpr dart::compiler::target::word
     Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    Thread_megamorphic_call_checked_entry_offset = 592;
+    Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    Thread_switchable_call_miss_entry_offset = 600;
+    Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -2635,27 +2645,27 @@
     Thread_range_error_shared_without_fpu_regs_stub_offset = 336;
 static constexpr dart::compiler::target::word Thread_object_null_offset = 200;
 static constexpr dart::compiler::target::word
-    Thread_predefined_symbols_address_offset = 672;
-static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1528;
+    Thread_predefined_symbols_address_offset = 680;
+static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1544;
 static constexpr dart::compiler::target::word
-    Thread_saved_shadow_call_stack_offset = 1536;
+    Thread_saved_shadow_call_stack_offset = 1552;
 static constexpr dart::compiler::target::word Thread_safepoint_state_offset =
-    1552;
+    1568;
 static constexpr dart::compiler::target::word
     Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    Thread_slow_type_test_entry_point_offset = 640;
+    Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word Thread_stack_limit_offset = 56;
 static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset =
     112;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word Thread_store_buffer_block_offset =
@@ -2672,18 +2682,18 @@
 static constexpr dart::compiler::target::word Thread_write_barrier_code_offset =
     224;
 static constexpr dart::compiler::target::word
-    Thread_write_barrier_entry_point_offset = 512;
+    Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset =
     64;
 static constexpr dart::compiler::target::word Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word Thread_callback_code_offset =
-    1560;
+    1576;
 static constexpr dart::compiler::target::word
-    Thread_callback_stack_return_offset = 1568;
-static constexpr dart::compiler::target::word Thread_random_offset = 1600;
+    Thread_callback_stack_return_offset = 1584;
+static constexpr dart::compiler::target::word Thread_random_offset = 1616;
 static constexpr dart::compiler::target::word
-    Thread_jump_to_frame_entry_point_offset = 632;
-static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1608;
+    Thread_jump_to_frame_entry_point_offset = 640;
+static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1624;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset =
     0;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset =
@@ -2754,8 +2764,8 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, -1,   -1,   1448, 1456,
-        1464, 1472, 1480, -1,   1488, 1496, -1,   -1};
+        1432, 1440, 1448, 1456, -1,   -1,   1464, 1472,
+        1480, 1488, 1496, -1,   1504, 1512, -1,   -1};
 static constexpr dart::compiler::target::word AbstractType_InstanceSize = 24;
 static constexpr dart::compiler::target::word ApiError_InstanceSize = 16;
 static constexpr dart::compiler::target::word Array_header_size = 16;
@@ -3075,95 +3085,97 @@
 static constexpr dart::compiler::target::word String_length_offset = 8;
 static constexpr dart::compiler::target::word SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    Thread_AllocateArray_entry_point_offset = 736;
+    Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word Thread_active_exception_offset =
-    1568;
+    1584;
 static constexpr dart::compiler::target::word Thread_active_stacktrace_offset =
-    1576;
+    1592;
 static constexpr dart::compiler::target::word
     Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    Thread_array_write_barrier_entry_point_offset = 520;
+    Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_entry_point_offset = 552;
+    Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_parameterized_entry_point_offset = 560;
+    Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_slow_entry_point_offset = 568;
+    Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word Thread_api_top_scope_offset =
-    1648;
+    1664;
 static constexpr dart::compiler::target::word
-    Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word Thread_bool_false_offset = 216;
 static constexpr dart::compiler::target::word Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    Thread_call_to_runtime_entry_point_offset = 528;
+    Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     Thread_call_to_runtime_stub_offset = 264;
-static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1688;
+static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1704;
 static constexpr dart::compiler::target::word
     Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    Thread_double_truncate_round_supported_offset = 1656;
+    Thread_double_truncate_round_supported_offset = 1672;
 static constexpr dart::compiler::target::word Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 440;
 static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset =
-    616;
+    624;
 static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset =
     448;
 static constexpr dart::compiler::target::word Thread_double_abs_address_offset =
-    696;
+    704;
 static constexpr dart::compiler::target::word
-    Thread_double_negate_address_offset = 688;
+    Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word Thread_execution_state_offset =
-    1608;
+    1624;
 static constexpr dart::compiler::target::word
     Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_stub_offset = 504;
+    Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_entry_point_offset = 624;
+    Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    Thread_float_absolute_address_offset = 720;
+    Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    Thread_float_negate_address_offset = 712;
+    Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word Thread_float_not_address_offset =
-    704;
+    712;
 static constexpr dart::compiler::target::word
-    Thread_float_zerow_address_offset = 728;
+    Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word Thread_global_object_pool_offset =
-    1584;
+    1600;
 static constexpr dart::compiler::target::word
     Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset =
-    1640;
+    1656;
 static constexpr dart::compiler::target::word Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word Thread_isolate_group_offset =
-    1696;
+    1712;
 static constexpr dart::compiler::target::word Thread_field_table_values_offset =
     128;
 static constexpr dart::compiler::target::word
@@ -3175,13 +3187,13 @@
 static constexpr dart::compiler::target::word
     Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    Thread_megamorphic_call_checked_entry_offset = 592;
+    Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    Thread_switchable_call_miss_entry_offset = 600;
+    Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -3204,27 +3216,27 @@
     Thread_range_error_shared_without_fpu_regs_stub_offset = 336;
 static constexpr dart::compiler::target::word Thread_object_null_offset = 200;
 static constexpr dart::compiler::target::word
-    Thread_predefined_symbols_address_offset = 672;
-static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1592;
+    Thread_predefined_symbols_address_offset = 680;
+static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1608;
 static constexpr dart::compiler::target::word
-    Thread_saved_shadow_call_stack_offset = 1600;
+    Thread_saved_shadow_call_stack_offset = 1616;
 static constexpr dart::compiler::target::word Thread_safepoint_state_offset =
-    1616;
+    1632;
 static constexpr dart::compiler::target::word
     Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    Thread_slow_type_test_entry_point_offset = 640;
+    Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word Thread_stack_limit_offset = 56;
 static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset =
     112;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word Thread_store_buffer_block_offset =
@@ -3241,18 +3253,18 @@
 static constexpr dart::compiler::target::word Thread_write_barrier_code_offset =
     224;
 static constexpr dart::compiler::target::word
-    Thread_write_barrier_entry_point_offset = 512;
+    Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset =
     64;
 static constexpr dart::compiler::target::word Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word Thread_callback_code_offset =
-    1624;
+    1640;
 static constexpr dart::compiler::target::word
-    Thread_callback_stack_return_offset = 1632;
-static constexpr dart::compiler::target::word Thread_random_offset = 1664;
+    Thread_callback_stack_return_offset = 1648;
+static constexpr dart::compiler::target::word Thread_random_offset = 1680;
 static constexpr dart::compiler::target::word
-    Thread_jump_to_frame_entry_point_offset = 632;
-static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1672;
+    Thread_jump_to_frame_entry_point_offset = 640;
+static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1688;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset =
     0;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset =
@@ -3323,9 +3335,9 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496,
-        1504, 1512, 1520, 1528, -1,   -1,   -1,   -1,   1536, 1544, -1,
-        -1,   1552, 1560, 1568, -1,   -1,   -1,   -1,   -1,   -1};
+        1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496, 1504, 1512,
+        1520, 1528, 1536, 1544, -1,   -1,   -1,   -1,   1552, 1560, -1,
+        -1,   1568, 1576, 1584, -1,   -1,   -1,   -1,   -1,   -1};
 static constexpr dart::compiler::target::word AbstractType_InstanceSize = 24;
 static constexpr dart::compiler::target::word ApiError_InstanceSize = 16;
 static constexpr dart::compiler::target::word Array_header_size = 16;
@@ -3639,93 +3651,95 @@
 static constexpr dart::compiler::target::word String_length_offset = 4;
 static constexpr dart::compiler::target::word SubtypeTestCache_cache_offset = 4;
 static constexpr dart::compiler::target::word
-    Thread_AllocateArray_entry_point_offset = 380;
+    Thread_AllocateArray_entry_point_offset = 384;
 static constexpr dart::compiler::target::word Thread_active_exception_offset =
-    752;
+    760;
 static constexpr dart::compiler::target::word Thread_active_stacktrace_offset =
-    756;
+    764;
 static constexpr dart::compiler::target::word
     Thread_array_write_barrier_code_offset = 128;
 static constexpr dart::compiler::target::word
-    Thread_array_write_barrier_entry_point_offset = 272;
+    Thread_array_write_barrier_entry_point_offset = 276;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 280;
+    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 284;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_with_fpu_regs_stub_offset = 188;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 284;
+    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 288;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_without_fpu_regs_stub_offset = 192;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_entry_point_offset = 288;
+    Thread_allocate_object_entry_point_offset = 292;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_stub_offset = 196;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_parameterized_entry_point_offset = 292;
+    Thread_allocate_object_parameterized_entry_point_offset = 296;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_parameterized_stub_offset = 200;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_slow_entry_point_offset = 296;
+    Thread_allocate_object_slow_entry_point_offset = 300;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_slow_stub_offset = 204;
-static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 792;
+static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 800;
 static constexpr dart::compiler::target::word
-    Thread_auto_scope_native_wrapper_entry_point_offset = 344;
+    Thread_auto_scope_native_wrapper_entry_point_offset = 348;
 static constexpr dart::compiler::target::word Thread_bool_false_offset = 120;
 static constexpr dart::compiler::target::word Thread_bool_true_offset = 116;
 static constexpr dart::compiler::target::word
-    Thread_bootstrap_native_wrapper_entry_point_offset = 336;
+    Thread_bootstrap_native_wrapper_entry_point_offset = 340;
 static constexpr dart::compiler::target::word
-    Thread_call_to_runtime_entry_point_offset = 276;
+    Thread_call_to_runtime_entry_point_offset = 280;
 static constexpr dart::compiler::target::word
     Thread_call_to_runtime_stub_offset = 144;
-static constexpr dart::compiler::target::word Thread_dart_stream_offset = 816;
+static constexpr dart::compiler::target::word Thread_dart_stream_offset = 824;
 static constexpr dart::compiler::target::word
     Thread_dispatch_table_array_offset = 44;
 static constexpr dart::compiler::target::word
-    Thread_double_truncate_round_supported_offset = 796;
+    Thread_double_truncate_round_supported_offset = 804;
 static constexpr dart::compiler::target::word Thread_optimize_entry_offset =
-    316;
+    320;
 static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 232;
 static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset =
-    320;
+    324;
 static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset =
     236;
 static constexpr dart::compiler::target::word Thread_double_abs_address_offset =
-    360;
+    364;
 static constexpr dart::compiler::target::word
-    Thread_double_negate_address_offset = 356;
+    Thread_double_negate_address_offset = 360;
 static constexpr dart::compiler::target::word Thread_end_offset = 52;
 static constexpr dart::compiler::target::word
     Thread_enter_safepoint_stub_offset = 256;
 static constexpr dart::compiler::target::word Thread_execution_state_offset =
-    772;
+    780;
 static constexpr dart::compiler::target::word
     Thread_exit_safepoint_stub_offset = 260;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_stub_offset = 264;
+    Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 264;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_entry_point_offset = 324;
+    Thread_call_native_through_safepoint_stub_offset = 268;
+static constexpr dart::compiler::target::word
+    Thread_call_native_through_safepoint_entry_point_offset = 328;
 static constexpr dart::compiler::target::word
     Thread_fix_allocation_stub_code_offset = 136;
 static constexpr dart::compiler::target::word
     Thread_fix_callers_target_code_offset = 132;
 static constexpr dart::compiler::target::word
-    Thread_float_absolute_address_offset = 372;
+    Thread_float_absolute_address_offset = 376;
 static constexpr dart::compiler::target::word
-    Thread_float_negate_address_offset = 368;
+    Thread_float_negate_address_offset = 372;
 static constexpr dart::compiler::target::word Thread_float_not_address_offset =
-    364;
+    368;
 static constexpr dart::compiler::target::word
-    Thread_float_zerow_address_offset = 376;
+    Thread_float_zerow_address_offset = 380;
 static constexpr dart::compiler::target::word Thread_global_object_pool_offset =
-    760;
+    768;
 static constexpr dart::compiler::target::word
     Thread_invoke_dart_code_stub_offset = 140;
 static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset =
-    788;
+    796;
 static constexpr dart::compiler::target::word Thread_isolate_offset = 40;
-static constexpr dart::compiler::target::word Thread_isolate_group_offset = 820;
+static constexpr dart::compiler::target::word Thread_isolate_group_offset = 828;
 static constexpr dart::compiler::target::word Thread_field_table_values_offset =
     64;
 static constexpr dart::compiler::target::word
@@ -3737,13 +3751,13 @@
 static constexpr dart::compiler::target::word
     Thread_marking_stack_block_offset = 80;
 static constexpr dart::compiler::target::word
-    Thread_megamorphic_call_checked_entry_offset = 308;
+    Thread_megamorphic_call_checked_entry_offset = 312;
 static constexpr dart::compiler::target::word
-    Thread_switchable_call_miss_entry_offset = 312;
+    Thread_switchable_call_miss_entry_offset = 316;
 static constexpr dart::compiler::target::word
     Thread_switchable_call_miss_stub_offset = 216;
 static constexpr dart::compiler::target::word
-    Thread_no_scope_native_wrapper_entry_point_offset = 340;
+    Thread_no_scope_native_wrapper_entry_point_offset = 344;
 static constexpr dart::compiler::target::word
     Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 152;
 static constexpr dart::compiler::target::word
@@ -3766,27 +3780,27 @@
     Thread_range_error_shared_without_fpu_regs_stub_offset = 180;
 static constexpr dart::compiler::target::word Thread_object_null_offset = 112;
 static constexpr dart::compiler::target::word
-    Thread_predefined_symbols_address_offset = 348;
-static constexpr dart::compiler::target::word Thread_resume_pc_offset = 764;
+    Thread_predefined_symbols_address_offset = 352;
+static constexpr dart::compiler::target::word Thread_resume_pc_offset = 772;
 static constexpr dart::compiler::target::word
-    Thread_saved_shadow_call_stack_offset = 768;
+    Thread_saved_shadow_call_stack_offset = 776;
 static constexpr dart::compiler::target::word Thread_safepoint_state_offset =
-    776;
+    784;
 static constexpr dart::compiler::target::word
     Thread_slow_type_test_stub_offset = 248;
 static constexpr dart::compiler::target::word
-    Thread_slow_type_test_entry_point_offset = 332;
+    Thread_slow_type_test_entry_point_offset = 336;
 static constexpr dart::compiler::target::word Thread_stack_limit_offset = 28;
 static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset =
     56;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_flags_offset = 60;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 304;
+    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 308;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 212;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 300;
+    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 304;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 208;
 static constexpr dart::compiler::target::word Thread_store_buffer_block_offset =
@@ -3803,17 +3817,17 @@
 static constexpr dart::compiler::target::word Thread_write_barrier_code_offset =
     124;
 static constexpr dart::compiler::target::word
-    Thread_write_barrier_entry_point_offset = 268;
+    Thread_write_barrier_entry_point_offset = 272;
 static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset =
     32;
 static constexpr dart::compiler::target::word Thread_heap_base_offset = 36;
-static constexpr dart::compiler::target::word Thread_callback_code_offset = 780;
+static constexpr dart::compiler::target::word Thread_callback_code_offset = 788;
 static constexpr dart::compiler::target::word
-    Thread_callback_stack_return_offset = 784;
-static constexpr dart::compiler::target::word Thread_random_offset = 800;
+    Thread_callback_stack_return_offset = 792;
+static constexpr dart::compiler::target::word Thread_random_offset = 808;
 static constexpr dart::compiler::target::word
-    Thread_jump_to_frame_entry_point_offset = 328;
-static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 808;
+    Thread_jump_to_frame_entry_point_offset = 332;
+static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 816;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset =
     0;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset =
@@ -3882,7 +3896,7 @@
     4, 12, 8, 16};
 static constexpr dart::compiler::target::word
     Thread_write_barrier_wrappers_thread_offset[] = {
-        720, 724, 728, 732, 736, -1, 740, -1, 744, 748, -1, -1, -1, -1, -1, -1};
+        728, 732, 736, 740, 744, -1, 748, -1, 752, 756, -1, -1, -1, -1, -1, -1};
 static constexpr dart::compiler::target::word AbstractType_InstanceSize = 12;
 static constexpr dart::compiler::target::word ApiError_InstanceSize = 8;
 static constexpr dart::compiler::target::word Array_header_size = 12;
@@ -4198,95 +4212,97 @@
 static constexpr dart::compiler::target::word String_length_offset = 8;
 static constexpr dart::compiler::target::word SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    Thread_AllocateArray_entry_point_offset = 736;
+    Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word Thread_active_exception_offset =
-    1504;
+    1520;
 static constexpr dart::compiler::target::word Thread_active_stacktrace_offset =
-    1512;
+    1528;
 static constexpr dart::compiler::target::word
     Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    Thread_array_write_barrier_entry_point_offset = 520;
+    Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_entry_point_offset = 552;
+    Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_parameterized_entry_point_offset = 560;
+    Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_slow_entry_point_offset = 568;
+    Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word Thread_api_top_scope_offset =
-    1584;
+    1600;
 static constexpr dart::compiler::target::word
-    Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word Thread_bool_false_offset = 216;
 static constexpr dart::compiler::target::word Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    Thread_call_to_runtime_entry_point_offset = 528;
+    Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     Thread_call_to_runtime_stub_offset = 264;
-static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1624;
+static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1640;
 static constexpr dart::compiler::target::word
     Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    Thread_double_truncate_round_supported_offset = 1592;
+    Thread_double_truncate_round_supported_offset = 1608;
 static constexpr dart::compiler::target::word Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 440;
 static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset =
-    616;
+    624;
 static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset =
     448;
 static constexpr dart::compiler::target::word Thread_double_abs_address_offset =
-    696;
+    704;
 static constexpr dart::compiler::target::word
-    Thread_double_negate_address_offset = 688;
+    Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word Thread_execution_state_offset =
-    1544;
+    1560;
 static constexpr dart::compiler::target::word
     Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_stub_offset = 504;
+    Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_entry_point_offset = 624;
+    Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    Thread_float_absolute_address_offset = 720;
+    Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    Thread_float_negate_address_offset = 712;
+    Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word Thread_float_not_address_offset =
-    704;
+    712;
 static constexpr dart::compiler::target::word
-    Thread_float_zerow_address_offset = 728;
+    Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word Thread_global_object_pool_offset =
-    1520;
+    1536;
 static constexpr dart::compiler::target::word
     Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset =
-    1576;
+    1592;
 static constexpr dart::compiler::target::word Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word Thread_isolate_group_offset =
-    1632;
+    1648;
 static constexpr dart::compiler::target::word Thread_field_table_values_offset =
     128;
 static constexpr dart::compiler::target::word
@@ -4298,13 +4314,13 @@
 static constexpr dart::compiler::target::word
     Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    Thread_megamorphic_call_checked_entry_offset = 592;
+    Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    Thread_switchable_call_miss_entry_offset = 600;
+    Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -4327,27 +4343,27 @@
     Thread_range_error_shared_without_fpu_regs_stub_offset = 336;
 static constexpr dart::compiler::target::word Thread_object_null_offset = 200;
 static constexpr dart::compiler::target::word
-    Thread_predefined_symbols_address_offset = 672;
-static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1528;
+    Thread_predefined_symbols_address_offset = 680;
+static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1544;
 static constexpr dart::compiler::target::word
-    Thread_saved_shadow_call_stack_offset = 1536;
+    Thread_saved_shadow_call_stack_offset = 1552;
 static constexpr dart::compiler::target::word Thread_safepoint_state_offset =
-    1552;
+    1568;
 static constexpr dart::compiler::target::word
     Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    Thread_slow_type_test_entry_point_offset = 640;
+    Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word Thread_stack_limit_offset = 56;
 static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset =
     112;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word Thread_store_buffer_block_offset =
@@ -4364,18 +4380,18 @@
 static constexpr dart::compiler::target::word Thread_write_barrier_code_offset =
     224;
 static constexpr dart::compiler::target::word
-    Thread_write_barrier_entry_point_offset = 512;
+    Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset =
     64;
 static constexpr dart::compiler::target::word Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word Thread_callback_code_offset =
-    1560;
+    1576;
 static constexpr dart::compiler::target::word
-    Thread_callback_stack_return_offset = 1568;
-static constexpr dart::compiler::target::word Thread_random_offset = 1600;
+    Thread_callback_stack_return_offset = 1584;
+static constexpr dart::compiler::target::word Thread_random_offset = 1616;
 static constexpr dart::compiler::target::word
-    Thread_jump_to_frame_entry_point_offset = 632;
-static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1608;
+    Thread_jump_to_frame_entry_point_offset = 640;
+static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1624;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset =
     0;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset =
@@ -4446,8 +4462,8 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, -1,   -1,   1448, 1456,
-        1464, 1472, 1480, -1,   1488, 1496, -1,   -1};
+        1432, 1440, 1448, 1456, -1,   -1,   1464, 1472,
+        1480, 1488, 1496, -1,   1504, 1512, -1,   -1};
 static constexpr dart::compiler::target::word AbstractType_InstanceSize = 24;
 static constexpr dart::compiler::target::word ApiError_InstanceSize = 16;
 static constexpr dart::compiler::target::word Array_header_size = 24;
@@ -4759,93 +4775,95 @@
 static constexpr dart::compiler::target::word String_length_offset = 4;
 static constexpr dart::compiler::target::word SubtypeTestCache_cache_offset = 4;
 static constexpr dart::compiler::target::word
-    Thread_AllocateArray_entry_point_offset = 380;
+    Thread_AllocateArray_entry_point_offset = 384;
 static constexpr dart::compiler::target::word Thread_active_exception_offset =
-    720;
+    728;
 static constexpr dart::compiler::target::word Thread_active_stacktrace_offset =
-    724;
+    732;
 static constexpr dart::compiler::target::word
     Thread_array_write_barrier_code_offset = 128;
 static constexpr dart::compiler::target::word
-    Thread_array_write_barrier_entry_point_offset = 272;
+    Thread_array_write_barrier_entry_point_offset = 276;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 280;
+    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 284;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_with_fpu_regs_stub_offset = 188;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 284;
+    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 288;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_without_fpu_regs_stub_offset = 192;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_entry_point_offset = 288;
+    Thread_allocate_object_entry_point_offset = 292;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_stub_offset = 196;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_parameterized_entry_point_offset = 292;
+    Thread_allocate_object_parameterized_entry_point_offset = 296;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_parameterized_stub_offset = 200;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_slow_entry_point_offset = 296;
+    Thread_allocate_object_slow_entry_point_offset = 300;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_slow_stub_offset = 204;
-static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 760;
+static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 768;
 static constexpr dart::compiler::target::word
-    Thread_auto_scope_native_wrapper_entry_point_offset = 344;
+    Thread_auto_scope_native_wrapper_entry_point_offset = 348;
 static constexpr dart::compiler::target::word Thread_bool_false_offset = 120;
 static constexpr dart::compiler::target::word Thread_bool_true_offset = 116;
 static constexpr dart::compiler::target::word
-    Thread_bootstrap_native_wrapper_entry_point_offset = 336;
+    Thread_bootstrap_native_wrapper_entry_point_offset = 340;
 static constexpr dart::compiler::target::word
-    Thread_call_to_runtime_entry_point_offset = 276;
+    Thread_call_to_runtime_entry_point_offset = 280;
 static constexpr dart::compiler::target::word
     Thread_call_to_runtime_stub_offset = 144;
-static constexpr dart::compiler::target::word Thread_dart_stream_offset = 784;
+static constexpr dart::compiler::target::word Thread_dart_stream_offset = 792;
 static constexpr dart::compiler::target::word
     Thread_dispatch_table_array_offset = 44;
 static constexpr dart::compiler::target::word
-    Thread_double_truncate_round_supported_offset = 764;
+    Thread_double_truncate_round_supported_offset = 772;
 static constexpr dart::compiler::target::word Thread_optimize_entry_offset =
-    316;
+    320;
 static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 232;
 static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset =
-    320;
+    324;
 static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset =
     236;
 static constexpr dart::compiler::target::word Thread_double_abs_address_offset =
-    360;
+    364;
 static constexpr dart::compiler::target::word
-    Thread_double_negate_address_offset = 356;
+    Thread_double_negate_address_offset = 360;
 static constexpr dart::compiler::target::word Thread_end_offset = 52;
 static constexpr dart::compiler::target::word
     Thread_enter_safepoint_stub_offset = 256;
 static constexpr dart::compiler::target::word Thread_execution_state_offset =
-    740;
+    748;
 static constexpr dart::compiler::target::word
     Thread_exit_safepoint_stub_offset = 260;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_stub_offset = 264;
+    Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 264;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_entry_point_offset = 324;
+    Thread_call_native_through_safepoint_stub_offset = 268;
+static constexpr dart::compiler::target::word
+    Thread_call_native_through_safepoint_entry_point_offset = 328;
 static constexpr dart::compiler::target::word
     Thread_fix_allocation_stub_code_offset = 136;
 static constexpr dart::compiler::target::word
     Thread_fix_callers_target_code_offset = 132;
 static constexpr dart::compiler::target::word
-    Thread_float_absolute_address_offset = 372;
+    Thread_float_absolute_address_offset = 376;
 static constexpr dart::compiler::target::word
-    Thread_float_negate_address_offset = 368;
+    Thread_float_negate_address_offset = 372;
 static constexpr dart::compiler::target::word Thread_float_not_address_offset =
-    364;
+    368;
 static constexpr dart::compiler::target::word
-    Thread_float_zerow_address_offset = 376;
+    Thread_float_zerow_address_offset = 380;
 static constexpr dart::compiler::target::word Thread_global_object_pool_offset =
-    728;
+    736;
 static constexpr dart::compiler::target::word
     Thread_invoke_dart_code_stub_offset = 140;
 static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset =
-    756;
+    764;
 static constexpr dart::compiler::target::word Thread_isolate_offset = 40;
-static constexpr dart::compiler::target::word Thread_isolate_group_offset = 788;
+static constexpr dart::compiler::target::word Thread_isolate_group_offset = 796;
 static constexpr dart::compiler::target::word Thread_field_table_values_offset =
     64;
 static constexpr dart::compiler::target::word
@@ -4857,13 +4875,13 @@
 static constexpr dart::compiler::target::word
     Thread_marking_stack_block_offset = 80;
 static constexpr dart::compiler::target::word
-    Thread_megamorphic_call_checked_entry_offset = 308;
+    Thread_megamorphic_call_checked_entry_offset = 312;
 static constexpr dart::compiler::target::word
-    Thread_switchable_call_miss_entry_offset = 312;
+    Thread_switchable_call_miss_entry_offset = 316;
 static constexpr dart::compiler::target::word
     Thread_switchable_call_miss_stub_offset = 216;
 static constexpr dart::compiler::target::word
-    Thread_no_scope_native_wrapper_entry_point_offset = 340;
+    Thread_no_scope_native_wrapper_entry_point_offset = 344;
 static constexpr dart::compiler::target::word
     Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 152;
 static constexpr dart::compiler::target::word
@@ -4886,27 +4904,27 @@
     Thread_range_error_shared_without_fpu_regs_stub_offset = 180;
 static constexpr dart::compiler::target::word Thread_object_null_offset = 112;
 static constexpr dart::compiler::target::word
-    Thread_predefined_symbols_address_offset = 348;
-static constexpr dart::compiler::target::word Thread_resume_pc_offset = 732;
+    Thread_predefined_symbols_address_offset = 352;
+static constexpr dart::compiler::target::word Thread_resume_pc_offset = 740;
 static constexpr dart::compiler::target::word
-    Thread_saved_shadow_call_stack_offset = 736;
+    Thread_saved_shadow_call_stack_offset = 744;
 static constexpr dart::compiler::target::word Thread_safepoint_state_offset =
-    744;
+    752;
 static constexpr dart::compiler::target::word
     Thread_slow_type_test_stub_offset = 248;
 static constexpr dart::compiler::target::word
-    Thread_slow_type_test_entry_point_offset = 332;
+    Thread_slow_type_test_entry_point_offset = 336;
 static constexpr dart::compiler::target::word Thread_stack_limit_offset = 28;
 static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset =
     56;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_flags_offset = 60;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 304;
+    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 308;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 212;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 300;
+    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 304;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 208;
 static constexpr dart::compiler::target::word Thread_store_buffer_block_offset =
@@ -4923,17 +4941,17 @@
 static constexpr dart::compiler::target::word Thread_write_barrier_code_offset =
     124;
 static constexpr dart::compiler::target::word
-    Thread_write_barrier_entry_point_offset = 268;
+    Thread_write_barrier_entry_point_offset = 272;
 static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset =
     32;
 static constexpr dart::compiler::target::word Thread_heap_base_offset = 36;
-static constexpr dart::compiler::target::word Thread_callback_code_offset = 748;
+static constexpr dart::compiler::target::word Thread_callback_code_offset = 756;
 static constexpr dart::compiler::target::word
-    Thread_callback_stack_return_offset = 752;
-static constexpr dart::compiler::target::word Thread_random_offset = 768;
+    Thread_callback_stack_return_offset = 760;
+static constexpr dart::compiler::target::word Thread_random_offset = 776;
 static constexpr dart::compiler::target::word
-    Thread_jump_to_frame_entry_point_offset = 328;
-static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 776;
+    Thread_jump_to_frame_entry_point_offset = 332;
+static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 784;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset =
     0;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset =
@@ -5315,95 +5333,97 @@
 static constexpr dart::compiler::target::word String_length_offset = 8;
 static constexpr dart::compiler::target::word SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    Thread_AllocateArray_entry_point_offset = 736;
+    Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word Thread_active_exception_offset =
-    1568;
+    1584;
 static constexpr dart::compiler::target::word Thread_active_stacktrace_offset =
-    1576;
+    1592;
 static constexpr dart::compiler::target::word
     Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    Thread_array_write_barrier_entry_point_offset = 520;
+    Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_entry_point_offset = 552;
+    Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_parameterized_entry_point_offset = 560;
+    Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_slow_entry_point_offset = 568;
+    Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word Thread_api_top_scope_offset =
-    1648;
+    1664;
 static constexpr dart::compiler::target::word
-    Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word Thread_bool_false_offset = 216;
 static constexpr dart::compiler::target::word Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    Thread_call_to_runtime_entry_point_offset = 528;
+    Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     Thread_call_to_runtime_stub_offset = 264;
-static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1688;
+static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1704;
 static constexpr dart::compiler::target::word
     Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    Thread_double_truncate_round_supported_offset = 1656;
+    Thread_double_truncate_round_supported_offset = 1672;
 static constexpr dart::compiler::target::word Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 440;
 static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset =
-    616;
+    624;
 static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset =
     448;
 static constexpr dart::compiler::target::word Thread_double_abs_address_offset =
-    696;
+    704;
 static constexpr dart::compiler::target::word
-    Thread_double_negate_address_offset = 688;
+    Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word Thread_execution_state_offset =
-    1608;
+    1624;
 static constexpr dart::compiler::target::word
     Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_stub_offset = 504;
+    Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_entry_point_offset = 624;
+    Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    Thread_float_absolute_address_offset = 720;
+    Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    Thread_float_negate_address_offset = 712;
+    Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word Thread_float_not_address_offset =
-    704;
+    712;
 static constexpr dart::compiler::target::word
-    Thread_float_zerow_address_offset = 728;
+    Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word Thread_global_object_pool_offset =
-    1584;
+    1600;
 static constexpr dart::compiler::target::word
     Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset =
-    1640;
+    1656;
 static constexpr dart::compiler::target::word Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word Thread_isolate_group_offset =
-    1696;
+    1712;
 static constexpr dart::compiler::target::word Thread_field_table_values_offset =
     128;
 static constexpr dart::compiler::target::word
@@ -5415,13 +5435,13 @@
 static constexpr dart::compiler::target::word
     Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    Thread_megamorphic_call_checked_entry_offset = 592;
+    Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    Thread_switchable_call_miss_entry_offset = 600;
+    Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -5444,27 +5464,27 @@
     Thread_range_error_shared_without_fpu_regs_stub_offset = 336;
 static constexpr dart::compiler::target::word Thread_object_null_offset = 200;
 static constexpr dart::compiler::target::word
-    Thread_predefined_symbols_address_offset = 672;
-static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1592;
+    Thread_predefined_symbols_address_offset = 680;
+static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1608;
 static constexpr dart::compiler::target::word
-    Thread_saved_shadow_call_stack_offset = 1600;
+    Thread_saved_shadow_call_stack_offset = 1616;
 static constexpr dart::compiler::target::word Thread_safepoint_state_offset =
-    1616;
+    1632;
 static constexpr dart::compiler::target::word
     Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    Thread_slow_type_test_entry_point_offset = 640;
+    Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word Thread_stack_limit_offset = 56;
 static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset =
     112;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word Thread_store_buffer_block_offset =
@@ -5481,18 +5501,18 @@
 static constexpr dart::compiler::target::word Thread_write_barrier_code_offset =
     224;
 static constexpr dart::compiler::target::word
-    Thread_write_barrier_entry_point_offset = 512;
+    Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset =
     64;
 static constexpr dart::compiler::target::word Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word Thread_callback_code_offset =
-    1624;
+    1640;
 static constexpr dart::compiler::target::word
-    Thread_callback_stack_return_offset = 1632;
-static constexpr dart::compiler::target::word Thread_random_offset = 1664;
+    Thread_callback_stack_return_offset = 1648;
+static constexpr dart::compiler::target::word Thread_random_offset = 1680;
 static constexpr dart::compiler::target::word
-    Thread_jump_to_frame_entry_point_offset = 632;
-static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1672;
+    Thread_jump_to_frame_entry_point_offset = 640;
+static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1688;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset =
     0;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset =
@@ -5563,9 +5583,9 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496,
-        1504, 1512, 1520, 1528, -1,   -1,   -1,   -1,   1536, 1544, -1,
-        -1,   1552, 1560, 1568, -1,   -1,   -1,   -1,   -1,   -1};
+        1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496, 1504, 1512,
+        1520, 1528, 1536, 1544, -1,   -1,   -1,   -1,   1552, 1560, -1,
+        -1,   1568, 1576, 1584, -1,   -1,   -1,   -1,   -1,   -1};
 static constexpr dart::compiler::target::word AbstractType_InstanceSize = 24;
 static constexpr dart::compiler::target::word ApiError_InstanceSize = 16;
 static constexpr dart::compiler::target::word Array_header_size = 24;
@@ -5879,95 +5899,97 @@
 static constexpr dart::compiler::target::word String_length_offset = 8;
 static constexpr dart::compiler::target::word SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    Thread_AllocateArray_entry_point_offset = 736;
+    Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word Thread_active_exception_offset =
-    1504;
+    1520;
 static constexpr dart::compiler::target::word Thread_active_stacktrace_offset =
-    1512;
+    1528;
 static constexpr dart::compiler::target::word
     Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    Thread_array_write_barrier_entry_point_offset = 520;
+    Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_entry_point_offset = 552;
+    Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_parameterized_entry_point_offset = 560;
+    Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_slow_entry_point_offset = 568;
+    Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word Thread_api_top_scope_offset =
-    1584;
+    1600;
 static constexpr dart::compiler::target::word
-    Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word Thread_bool_false_offset = 216;
 static constexpr dart::compiler::target::word Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    Thread_call_to_runtime_entry_point_offset = 528;
+    Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     Thread_call_to_runtime_stub_offset = 264;
-static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1624;
+static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1640;
 static constexpr dart::compiler::target::word
     Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    Thread_double_truncate_round_supported_offset = 1592;
+    Thread_double_truncate_round_supported_offset = 1608;
 static constexpr dart::compiler::target::word Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 440;
 static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset =
-    616;
+    624;
 static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset =
     448;
 static constexpr dart::compiler::target::word Thread_double_abs_address_offset =
-    696;
+    704;
 static constexpr dart::compiler::target::word
-    Thread_double_negate_address_offset = 688;
+    Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word Thread_execution_state_offset =
-    1544;
+    1560;
 static constexpr dart::compiler::target::word
     Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_stub_offset = 504;
+    Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_entry_point_offset = 624;
+    Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    Thread_float_absolute_address_offset = 720;
+    Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    Thread_float_negate_address_offset = 712;
+    Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word Thread_float_not_address_offset =
-    704;
+    712;
 static constexpr dart::compiler::target::word
-    Thread_float_zerow_address_offset = 728;
+    Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word Thread_global_object_pool_offset =
-    1520;
+    1536;
 static constexpr dart::compiler::target::word
     Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset =
-    1576;
+    1592;
 static constexpr dart::compiler::target::word Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word Thread_isolate_group_offset =
-    1632;
+    1648;
 static constexpr dart::compiler::target::word Thread_field_table_values_offset =
     128;
 static constexpr dart::compiler::target::word
@@ -5979,13 +6001,13 @@
 static constexpr dart::compiler::target::word
     Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    Thread_megamorphic_call_checked_entry_offset = 592;
+    Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    Thread_switchable_call_miss_entry_offset = 600;
+    Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -6008,27 +6030,27 @@
     Thread_range_error_shared_without_fpu_regs_stub_offset = 336;
 static constexpr dart::compiler::target::word Thread_object_null_offset = 200;
 static constexpr dart::compiler::target::word
-    Thread_predefined_symbols_address_offset = 672;
-static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1528;
+    Thread_predefined_symbols_address_offset = 680;
+static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1544;
 static constexpr dart::compiler::target::word
-    Thread_saved_shadow_call_stack_offset = 1536;
+    Thread_saved_shadow_call_stack_offset = 1552;
 static constexpr dart::compiler::target::word Thread_safepoint_state_offset =
-    1552;
+    1568;
 static constexpr dart::compiler::target::word
     Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    Thread_slow_type_test_entry_point_offset = 640;
+    Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word Thread_stack_limit_offset = 56;
 static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset =
     112;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word Thread_store_buffer_block_offset =
@@ -6045,18 +6067,18 @@
 static constexpr dart::compiler::target::word Thread_write_barrier_code_offset =
     224;
 static constexpr dart::compiler::target::word
-    Thread_write_barrier_entry_point_offset = 512;
+    Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset =
     64;
 static constexpr dart::compiler::target::word Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word Thread_callback_code_offset =
-    1560;
+    1576;
 static constexpr dart::compiler::target::word
-    Thread_callback_stack_return_offset = 1568;
-static constexpr dart::compiler::target::word Thread_random_offset = 1600;
+    Thread_callback_stack_return_offset = 1584;
+static constexpr dart::compiler::target::word Thread_random_offset = 1616;
 static constexpr dart::compiler::target::word
-    Thread_jump_to_frame_entry_point_offset = 632;
-static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1608;
+    Thread_jump_to_frame_entry_point_offset = 640;
+static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1624;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset =
     0;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset =
@@ -6127,8 +6149,8 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, -1,   -1,   1448, 1456,
-        1464, 1472, 1480, -1,   1488, 1496, -1,   -1};
+        1432, 1440, 1448, 1456, -1,   -1,   1464, 1472,
+        1480, 1488, 1496, -1,   1504, 1512, -1,   -1};
 static constexpr dart::compiler::target::word AbstractType_InstanceSize = 24;
 static constexpr dart::compiler::target::word ApiError_InstanceSize = 16;
 static constexpr dart::compiler::target::word Array_header_size = 16;
@@ -6442,95 +6464,97 @@
 static constexpr dart::compiler::target::word String_length_offset = 8;
 static constexpr dart::compiler::target::word SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    Thread_AllocateArray_entry_point_offset = 736;
+    Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word Thread_active_exception_offset =
-    1568;
+    1584;
 static constexpr dart::compiler::target::word Thread_active_stacktrace_offset =
-    1576;
+    1592;
 static constexpr dart::compiler::target::word
     Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    Thread_array_write_barrier_entry_point_offset = 520;
+    Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_entry_point_offset = 552;
+    Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_parameterized_entry_point_offset = 560;
+    Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    Thread_allocate_object_slow_entry_point_offset = 568;
+    Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word Thread_api_top_scope_offset =
-    1648;
+    1664;
 static constexpr dart::compiler::target::word
-    Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word Thread_bool_false_offset = 216;
 static constexpr dart::compiler::target::word Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    Thread_call_to_runtime_entry_point_offset = 528;
+    Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     Thread_call_to_runtime_stub_offset = 264;
-static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1688;
+static constexpr dart::compiler::target::word Thread_dart_stream_offset = 1704;
 static constexpr dart::compiler::target::word
     Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    Thread_double_truncate_round_supported_offset = 1656;
+    Thread_double_truncate_round_supported_offset = 1672;
 static constexpr dart::compiler::target::word Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 440;
 static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset =
-    616;
+    624;
 static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset =
     448;
 static constexpr dart::compiler::target::word Thread_double_abs_address_offset =
-    696;
+    704;
 static constexpr dart::compiler::target::word
-    Thread_double_negate_address_offset = 688;
+    Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word Thread_execution_state_offset =
-    1608;
+    1624;
 static constexpr dart::compiler::target::word
     Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_stub_offset = 504;
+    Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    Thread_call_native_through_safepoint_entry_point_offset = 624;
+    Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    Thread_float_absolute_address_offset = 720;
+    Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    Thread_float_negate_address_offset = 712;
+    Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word Thread_float_not_address_offset =
-    704;
+    712;
 static constexpr dart::compiler::target::word
-    Thread_float_zerow_address_offset = 728;
+    Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word Thread_global_object_pool_offset =
-    1584;
+    1600;
 static constexpr dart::compiler::target::word
     Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset =
-    1640;
+    1656;
 static constexpr dart::compiler::target::word Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word Thread_isolate_group_offset =
-    1696;
+    1712;
 static constexpr dart::compiler::target::word Thread_field_table_values_offset =
     128;
 static constexpr dart::compiler::target::word
@@ -6542,13 +6566,13 @@
 static constexpr dart::compiler::target::word
     Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    Thread_megamorphic_call_checked_entry_offset = 592;
+    Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    Thread_switchable_call_miss_entry_offset = 600;
+    Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -6571,27 +6595,27 @@
     Thread_range_error_shared_without_fpu_regs_stub_offset = 336;
 static constexpr dart::compiler::target::word Thread_object_null_offset = 200;
 static constexpr dart::compiler::target::word
-    Thread_predefined_symbols_address_offset = 672;
-static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1592;
+    Thread_predefined_symbols_address_offset = 680;
+static constexpr dart::compiler::target::word Thread_resume_pc_offset = 1608;
 static constexpr dart::compiler::target::word
-    Thread_saved_shadow_call_stack_offset = 1600;
+    Thread_saved_shadow_call_stack_offset = 1616;
 static constexpr dart::compiler::target::word Thread_safepoint_state_offset =
-    1616;
+    1632;
 static constexpr dart::compiler::target::word
     Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    Thread_slow_type_test_entry_point_offset = 640;
+    Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word Thread_stack_limit_offset = 56;
 static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset =
     112;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word Thread_store_buffer_block_offset =
@@ -6608,18 +6632,18 @@
 static constexpr dart::compiler::target::word Thread_write_barrier_code_offset =
     224;
 static constexpr dart::compiler::target::word
-    Thread_write_barrier_entry_point_offset = 512;
+    Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset =
     64;
 static constexpr dart::compiler::target::word Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word Thread_callback_code_offset =
-    1624;
+    1640;
 static constexpr dart::compiler::target::word
-    Thread_callback_stack_return_offset = 1632;
-static constexpr dart::compiler::target::word Thread_random_offset = 1664;
+    Thread_callback_stack_return_offset = 1648;
+static constexpr dart::compiler::target::word Thread_random_offset = 1680;
 static constexpr dart::compiler::target::word
-    Thread_jump_to_frame_entry_point_offset = 632;
-static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1672;
+    Thread_jump_to_frame_entry_point_offset = 640;
+static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 1688;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset =
     0;
 static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset =
@@ -6690,9 +6714,9 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496,
-        1504, 1512, 1520, 1528, -1,   -1,   -1,   -1,   1536, 1544, -1,
-        -1,   1552, 1560, 1568, -1,   -1,   -1,   -1,   -1,   -1};
+        1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496, 1504, 1512,
+        1520, 1528, 1536, 1544, -1,   -1,   -1,   -1,   1552, 1560, -1,
+        -1,   1568, 1576, 1584, -1,   -1,   -1,   -1,   -1,   -1};
 static constexpr dart::compiler::target::word AbstractType_InstanceSize = 24;
 static constexpr dart::compiler::target::word ApiError_InstanceSize = 16;
 static constexpr dart::compiler::target::word Array_header_size = 16;
@@ -7043,98 +7067,100 @@
 static constexpr dart::compiler::target::word
     AOT_SubtypeTestCache_cache_offset = 4;
 static constexpr dart::compiler::target::word
-    AOT_Thread_AllocateArray_entry_point_offset = 380;
+    AOT_Thread_AllocateArray_entry_point_offset = 384;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_exception_offset = 752;
+    AOT_Thread_active_exception_offset = 760;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_stacktrace_offset = 756;
+    AOT_Thread_active_stacktrace_offset = 764;
 static constexpr dart::compiler::target::word
     AOT_Thread_array_write_barrier_code_offset = 128;
 static constexpr dart::compiler::target::word
-    AOT_Thread_array_write_barrier_entry_point_offset = 272;
+    AOT_Thread_array_write_barrier_entry_point_offset = 276;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 280;
+    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 284;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 188;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 284;
+    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 288;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 192;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_entry_point_offset = 288;
+    AOT_Thread_allocate_object_entry_point_offset = 292;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_stub_offset = 196;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_parameterized_entry_point_offset = 292;
+    AOT_Thread_allocate_object_parameterized_entry_point_offset = 296;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_parameterized_stub_offset = 200;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_slow_entry_point_offset = 296;
+    AOT_Thread_allocate_object_slow_entry_point_offset = 300;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_slow_stub_offset = 204;
 static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset =
-    792;
+    800;
 static constexpr dart::compiler::target::word
-    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 344;
+    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 348;
 static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset =
     120;
 static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 116;
 static constexpr dart::compiler::target::word
-    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 336;
+    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 340;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_to_runtime_entry_point_offset = 276;
+    AOT_Thread_call_to_runtime_entry_point_offset = 280;
 static constexpr dart::compiler::target::word
     AOT_Thread_call_to_runtime_stub_offset = 144;
 static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset =
-    816;
+    824;
 static constexpr dart::compiler::target::word
     AOT_Thread_dispatch_table_array_offset = 44;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_truncate_round_supported_offset = 796;
+    AOT_Thread_double_truncate_round_supported_offset = 804;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset =
-    316;
+    320;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset =
     232;
 static constexpr dart::compiler::target::word
-    AOT_Thread_deoptimize_entry_offset = 320;
+    AOT_Thread_deoptimize_entry_offset = 324;
 static constexpr dart::compiler::target::word
     AOT_Thread_deoptimize_stub_offset = 236;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_abs_address_offset = 360;
+    AOT_Thread_double_abs_address_offset = 364;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_negate_address_offset = 356;
+    AOT_Thread_double_negate_address_offset = 360;
 static constexpr dart::compiler::target::word AOT_Thread_end_offset = 52;
 static constexpr dart::compiler::target::word
     AOT_Thread_enter_safepoint_stub_offset = 256;
 static constexpr dart::compiler::target::word
-    AOT_Thread_execution_state_offset = 772;
+    AOT_Thread_execution_state_offset = 780;
 static constexpr dart::compiler::target::word
     AOT_Thread_exit_safepoint_stub_offset = 260;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_stub_offset = 264;
+    AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 264;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_entry_point_offset = 324;
+    AOT_Thread_call_native_through_safepoint_stub_offset = 268;
+static constexpr dart::compiler::target::word
+    AOT_Thread_call_native_through_safepoint_entry_point_offset = 328;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_allocation_stub_code_offset = 136;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_callers_target_code_offset = 132;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_absolute_address_offset = 372;
+    AOT_Thread_float_absolute_address_offset = 376;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_negate_address_offset = 368;
+    AOT_Thread_float_negate_address_offset = 372;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_not_address_offset = 364;
+    AOT_Thread_float_not_address_offset = 368;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_zerow_address_offset = 376;
+    AOT_Thread_float_zerow_address_offset = 380;
 static constexpr dart::compiler::target::word
-    AOT_Thread_global_object_pool_offset = 760;
+    AOT_Thread_global_object_pool_offset = 768;
 static constexpr dart::compiler::target::word
     AOT_Thread_invoke_dart_code_stub_offset = 140;
 static constexpr dart::compiler::target::word
-    AOT_Thread_exit_through_ffi_offset = 788;
+    AOT_Thread_exit_through_ffi_offset = 796;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 40;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset =
-    820;
+    828;
 static constexpr dart::compiler::target::word
     AOT_Thread_field_table_values_offset = 64;
 static constexpr dart::compiler::target::word
@@ -7146,13 +7172,13 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_marking_stack_block_offset = 80;
 static constexpr dart::compiler::target::word
-    AOT_Thread_megamorphic_call_checked_entry_offset = 308;
+    AOT_Thread_megamorphic_call_checked_entry_offset = 312;
 static constexpr dart::compiler::target::word
-    AOT_Thread_switchable_call_miss_entry_offset = 312;
+    AOT_Thread_switchable_call_miss_entry_offset = 316;
 static constexpr dart::compiler::target::word
     AOT_Thread_switchable_call_miss_stub_offset = 216;
 static constexpr dart::compiler::target::word
-    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 340;
+    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 344;
 static constexpr dart::compiler::target::word
     AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 152;
 static constexpr dart::compiler::target::word
@@ -7177,16 +7203,16 @@
 static constexpr dart::compiler::target::word AOT_Thread_object_null_offset =
     112;
 static constexpr dart::compiler::target::word
-    AOT_Thread_predefined_symbols_address_offset = 348;
-static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = 764;
+    AOT_Thread_predefined_symbols_address_offset = 352;
+static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = 772;
 static constexpr dart::compiler::target::word
-    AOT_Thread_saved_shadow_call_stack_offset = 768;
+    AOT_Thread_saved_shadow_call_stack_offset = 776;
 static constexpr dart::compiler::target::word
-    AOT_Thread_safepoint_state_offset = 776;
+    AOT_Thread_safepoint_state_offset = 784;
 static constexpr dart::compiler::target::word
     AOT_Thread_slow_type_test_stub_offset = 248;
 static constexpr dart::compiler::target::word
-    AOT_Thread_slow_type_test_entry_point_offset = 332;
+    AOT_Thread_slow_type_test_entry_point_offset = 336;
 static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset =
     28;
 static constexpr dart::compiler::target::word
@@ -7194,11 +7220,11 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_flags_offset = 60;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 304;
+    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 308;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 212;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 300;
+    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 304;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 208;
 static constexpr dart::compiler::target::word
@@ -7216,19 +7242,19 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_code_offset = 124;
 static constexpr dart::compiler::target::word
-    AOT_Thread_write_barrier_entry_point_offset = 268;
+    AOT_Thread_write_barrier_entry_point_offset = 272;
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_mask_offset = 32;
 static constexpr dart::compiler::target::word AOT_Thread_heap_base_offset = 36;
 static constexpr dart::compiler::target::word AOT_Thread_callback_code_offset =
-    780;
+    788;
 static constexpr dart::compiler::target::word
-    AOT_Thread_callback_stack_return_offset = 784;
-static constexpr dart::compiler::target::word AOT_Thread_random_offset = 800;
+    AOT_Thread_callback_stack_return_offset = 792;
+static constexpr dart::compiler::target::word AOT_Thread_random_offset = 808;
 static constexpr dart::compiler::target::word
-    AOT_Thread_jump_to_frame_entry_point_offset = 328;
+    AOT_Thread_jump_to_frame_entry_point_offset = 332;
 static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset =
-    808;
+    816;
 static constexpr dart::compiler::target::word
     AOT_TsanUtils_setjmp_function_offset = 0;
 static constexpr dart::compiler::target::word
@@ -7311,7 +7337,7 @@
     4, 12, 8, 16};
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_wrappers_thread_offset[] = {
-        720, 724, 728, 732, 736, -1, 740, -1, 744, 748, -1, -1, -1, -1, -1, -1};
+        728, 732, 736, 740, 744, -1, 748, -1, 752, 756, -1, -1, -1, -1, -1, -1};
 static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize =
     12;
 static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 8;
@@ -7673,98 +7699,100 @@
 static constexpr dart::compiler::target::word
     AOT_SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    AOT_Thread_AllocateArray_entry_point_offset = 736;
+    AOT_Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_exception_offset = 1504;
+    AOT_Thread_active_exception_offset = 1520;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_stacktrace_offset = 1512;
+    AOT_Thread_active_stacktrace_offset = 1528;
 static constexpr dart::compiler::target::word
     AOT_Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    AOT_Thread_array_write_barrier_entry_point_offset = 520;
+    AOT_Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_entry_point_offset = 552;
+    AOT_Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_parameterized_entry_point_offset = 560;
+    AOT_Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_slow_entry_point_offset = 568;
+    AOT_Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset =
-    1584;
+    1600;
 static constexpr dart::compiler::target::word
-    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset =
     216;
 static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_to_runtime_entry_point_offset = 528;
+    AOT_Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     AOT_Thread_call_to_runtime_stub_offset = 264;
 static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset =
-    1624;
+    1640;
 static constexpr dart::compiler::target::word
     AOT_Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_truncate_round_supported_offset = 1592;
+    AOT_Thread_double_truncate_round_supported_offset = 1608;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset =
     440;
 static constexpr dart::compiler::target::word
-    AOT_Thread_deoptimize_entry_offset = 616;
+    AOT_Thread_deoptimize_entry_offset = 624;
 static constexpr dart::compiler::target::word
     AOT_Thread_deoptimize_stub_offset = 448;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_abs_address_offset = 696;
+    AOT_Thread_double_abs_address_offset = 704;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_negate_address_offset = 688;
+    AOT_Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word AOT_Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     AOT_Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word
-    AOT_Thread_execution_state_offset = 1544;
+    AOT_Thread_execution_state_offset = 1560;
 static constexpr dart::compiler::target::word
     AOT_Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_stub_offset = 504;
+    AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_entry_point_offset = 624;
+    AOT_Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    AOT_Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_absolute_address_offset = 720;
+    AOT_Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_negate_address_offset = 712;
+    AOT_Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_not_address_offset = 704;
+    AOT_Thread_float_not_address_offset = 712;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_zerow_address_offset = 728;
+    AOT_Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word
-    AOT_Thread_global_object_pool_offset = 1520;
+    AOT_Thread_global_object_pool_offset = 1536;
 static constexpr dart::compiler::target::word
     AOT_Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word
-    AOT_Thread_exit_through_ffi_offset = 1576;
+    AOT_Thread_exit_through_ffi_offset = 1592;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset =
-    1632;
+    1648;
 static constexpr dart::compiler::target::word
     AOT_Thread_field_table_values_offset = 128;
 static constexpr dart::compiler::target::word
@@ -7776,13 +7804,13 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    AOT_Thread_megamorphic_call_checked_entry_offset = 592;
+    AOT_Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    AOT_Thread_switchable_call_miss_entry_offset = 600;
+    AOT_Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     AOT_Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -7807,17 +7835,17 @@
 static constexpr dart::compiler::target::word AOT_Thread_object_null_offset =
     200;
 static constexpr dart::compiler::target::word
-    AOT_Thread_predefined_symbols_address_offset = 672;
+    AOT_Thread_predefined_symbols_address_offset = 680;
 static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset =
-    1528;
+    1544;
 static constexpr dart::compiler::target::word
-    AOT_Thread_saved_shadow_call_stack_offset = 1536;
+    AOT_Thread_saved_shadow_call_stack_offset = 1552;
 static constexpr dart::compiler::target::word
-    AOT_Thread_safepoint_state_offset = 1552;
+    AOT_Thread_safepoint_state_offset = 1568;
 static constexpr dart::compiler::target::word
     AOT_Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    AOT_Thread_slow_type_test_entry_point_offset = 640;
+    AOT_Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset =
     56;
 static constexpr dart::compiler::target::word
@@ -7825,11 +7853,11 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word
@@ -7847,19 +7875,19 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_code_offset = 224;
 static constexpr dart::compiler::target::word
-    AOT_Thread_write_barrier_entry_point_offset = 512;
+    AOT_Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_mask_offset = 64;
 static constexpr dart::compiler::target::word AOT_Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word AOT_Thread_callback_code_offset =
-    1560;
+    1576;
 static constexpr dart::compiler::target::word
-    AOT_Thread_callback_stack_return_offset = 1568;
-static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1600;
+    AOT_Thread_callback_stack_return_offset = 1584;
+static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1616;
 static constexpr dart::compiler::target::word
-    AOT_Thread_jump_to_frame_entry_point_offset = 632;
+    AOT_Thread_jump_to_frame_entry_point_offset = 640;
 static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset =
-    1608;
+    1624;
 static constexpr dart::compiler::target::word
     AOT_TsanUtils_setjmp_function_offset = 0;
 static constexpr dart::compiler::target::word
@@ -7943,8 +7971,8 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, -1,   -1,   1448, 1456,
-        1464, 1472, 1480, -1,   1488, 1496, -1,   -1};
+        1432, 1440, 1448, 1456, -1,   -1,   1464, 1472,
+        1480, 1488, 1496, -1,   1504, 1512, -1,   -1};
 static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize =
     24;
 static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 16;
@@ -8309,98 +8337,100 @@
 static constexpr dart::compiler::target::word
     AOT_SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    AOT_Thread_AllocateArray_entry_point_offset = 736;
+    AOT_Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_exception_offset = 1568;
+    AOT_Thread_active_exception_offset = 1584;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_stacktrace_offset = 1576;
+    AOT_Thread_active_stacktrace_offset = 1592;
 static constexpr dart::compiler::target::word
     AOT_Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    AOT_Thread_array_write_barrier_entry_point_offset = 520;
+    AOT_Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_entry_point_offset = 552;
+    AOT_Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_parameterized_entry_point_offset = 560;
+    AOT_Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_slow_entry_point_offset = 568;
+    AOT_Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset =
-    1648;
+    1664;
 static constexpr dart::compiler::target::word
-    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset =
     216;
 static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_to_runtime_entry_point_offset = 528;
+    AOT_Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     AOT_Thread_call_to_runtime_stub_offset = 264;
 static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset =
-    1688;
+    1704;
 static constexpr dart::compiler::target::word
     AOT_Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_truncate_round_supported_offset = 1656;
+    AOT_Thread_double_truncate_round_supported_offset = 1672;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset =
     440;
 static constexpr dart::compiler::target::word
-    AOT_Thread_deoptimize_entry_offset = 616;
+    AOT_Thread_deoptimize_entry_offset = 624;
 static constexpr dart::compiler::target::word
     AOT_Thread_deoptimize_stub_offset = 448;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_abs_address_offset = 696;
+    AOT_Thread_double_abs_address_offset = 704;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_negate_address_offset = 688;
+    AOT_Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word AOT_Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     AOT_Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word
-    AOT_Thread_execution_state_offset = 1608;
+    AOT_Thread_execution_state_offset = 1624;
 static constexpr dart::compiler::target::word
     AOT_Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_stub_offset = 504;
+    AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_entry_point_offset = 624;
+    AOT_Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    AOT_Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_absolute_address_offset = 720;
+    AOT_Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_negate_address_offset = 712;
+    AOT_Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_not_address_offset = 704;
+    AOT_Thread_float_not_address_offset = 712;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_zerow_address_offset = 728;
+    AOT_Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word
-    AOT_Thread_global_object_pool_offset = 1584;
+    AOT_Thread_global_object_pool_offset = 1600;
 static constexpr dart::compiler::target::word
     AOT_Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word
-    AOT_Thread_exit_through_ffi_offset = 1640;
+    AOT_Thread_exit_through_ffi_offset = 1656;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset =
-    1696;
+    1712;
 static constexpr dart::compiler::target::word
     AOT_Thread_field_table_values_offset = 128;
 static constexpr dart::compiler::target::word
@@ -8412,13 +8442,13 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    AOT_Thread_megamorphic_call_checked_entry_offset = 592;
+    AOT_Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    AOT_Thread_switchable_call_miss_entry_offset = 600;
+    AOT_Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     AOT_Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -8443,17 +8473,17 @@
 static constexpr dart::compiler::target::word AOT_Thread_object_null_offset =
     200;
 static constexpr dart::compiler::target::word
-    AOT_Thread_predefined_symbols_address_offset = 672;
+    AOT_Thread_predefined_symbols_address_offset = 680;
 static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset =
-    1592;
+    1608;
 static constexpr dart::compiler::target::word
-    AOT_Thread_saved_shadow_call_stack_offset = 1600;
+    AOT_Thread_saved_shadow_call_stack_offset = 1616;
 static constexpr dart::compiler::target::word
-    AOT_Thread_safepoint_state_offset = 1616;
+    AOT_Thread_safepoint_state_offset = 1632;
 static constexpr dart::compiler::target::word
     AOT_Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    AOT_Thread_slow_type_test_entry_point_offset = 640;
+    AOT_Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset =
     56;
 static constexpr dart::compiler::target::word
@@ -8461,11 +8491,11 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word
@@ -8483,19 +8513,19 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_code_offset = 224;
 static constexpr dart::compiler::target::word
-    AOT_Thread_write_barrier_entry_point_offset = 512;
+    AOT_Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_mask_offset = 64;
 static constexpr dart::compiler::target::word AOT_Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word AOT_Thread_callback_code_offset =
-    1624;
+    1640;
 static constexpr dart::compiler::target::word
-    AOT_Thread_callback_stack_return_offset = 1632;
-static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1664;
+    AOT_Thread_callback_stack_return_offset = 1648;
+static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1680;
 static constexpr dart::compiler::target::word
-    AOT_Thread_jump_to_frame_entry_point_offset = 632;
+    AOT_Thread_jump_to_frame_entry_point_offset = 640;
 static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset =
-    1672;
+    1688;
 static constexpr dart::compiler::target::word
     AOT_TsanUtils_setjmp_function_offset = 0;
 static constexpr dart::compiler::target::word
@@ -8579,9 +8609,9 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496,
-        1504, 1512, 1520, 1528, -1,   -1,   -1,   -1,   1536, 1544, -1,
-        -1,   1552, 1560, 1568, -1,   -1,   -1,   -1,   -1,   -1};
+        1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496, 1504, 1512,
+        1520, 1528, 1536, 1544, -1,   -1,   -1,   -1,   1552, 1560, -1,
+        -1,   1568, 1576, 1584, -1,   -1,   -1,   -1,   -1,   -1};
 static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize =
     24;
 static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 16;
@@ -8942,98 +8972,100 @@
 static constexpr dart::compiler::target::word
     AOT_SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    AOT_Thread_AllocateArray_entry_point_offset = 736;
+    AOT_Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_exception_offset = 1504;
+    AOT_Thread_active_exception_offset = 1520;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_stacktrace_offset = 1512;
+    AOT_Thread_active_stacktrace_offset = 1528;
 static constexpr dart::compiler::target::word
     AOT_Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    AOT_Thread_array_write_barrier_entry_point_offset = 520;
+    AOT_Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_entry_point_offset = 552;
+    AOT_Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_parameterized_entry_point_offset = 560;
+    AOT_Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_slow_entry_point_offset = 568;
+    AOT_Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset =
-    1584;
+    1600;
 static constexpr dart::compiler::target::word
-    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset =
     216;
 static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_to_runtime_entry_point_offset = 528;
+    AOT_Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     AOT_Thread_call_to_runtime_stub_offset = 264;
 static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset =
-    1624;
+    1640;
 static constexpr dart::compiler::target::word
     AOT_Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_truncate_round_supported_offset = 1592;
+    AOT_Thread_double_truncate_round_supported_offset = 1608;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset =
     440;
 static constexpr dart::compiler::target::word
-    AOT_Thread_deoptimize_entry_offset = 616;
+    AOT_Thread_deoptimize_entry_offset = 624;
 static constexpr dart::compiler::target::word
     AOT_Thread_deoptimize_stub_offset = 448;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_abs_address_offset = 696;
+    AOT_Thread_double_abs_address_offset = 704;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_negate_address_offset = 688;
+    AOT_Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word AOT_Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     AOT_Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word
-    AOT_Thread_execution_state_offset = 1544;
+    AOT_Thread_execution_state_offset = 1560;
 static constexpr dart::compiler::target::word
     AOT_Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_stub_offset = 504;
+    AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_entry_point_offset = 624;
+    AOT_Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    AOT_Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_absolute_address_offset = 720;
+    AOT_Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_negate_address_offset = 712;
+    AOT_Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_not_address_offset = 704;
+    AOT_Thread_float_not_address_offset = 712;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_zerow_address_offset = 728;
+    AOT_Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word
-    AOT_Thread_global_object_pool_offset = 1520;
+    AOT_Thread_global_object_pool_offset = 1536;
 static constexpr dart::compiler::target::word
     AOT_Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word
-    AOT_Thread_exit_through_ffi_offset = 1576;
+    AOT_Thread_exit_through_ffi_offset = 1592;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset =
-    1632;
+    1648;
 static constexpr dart::compiler::target::word
     AOT_Thread_field_table_values_offset = 128;
 static constexpr dart::compiler::target::word
@@ -9045,13 +9077,13 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    AOT_Thread_megamorphic_call_checked_entry_offset = 592;
+    AOT_Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    AOT_Thread_switchable_call_miss_entry_offset = 600;
+    AOT_Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     AOT_Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -9076,17 +9108,17 @@
 static constexpr dart::compiler::target::word AOT_Thread_object_null_offset =
     200;
 static constexpr dart::compiler::target::word
-    AOT_Thread_predefined_symbols_address_offset = 672;
+    AOT_Thread_predefined_symbols_address_offset = 680;
 static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset =
-    1528;
+    1544;
 static constexpr dart::compiler::target::word
-    AOT_Thread_saved_shadow_call_stack_offset = 1536;
+    AOT_Thread_saved_shadow_call_stack_offset = 1552;
 static constexpr dart::compiler::target::word
-    AOT_Thread_safepoint_state_offset = 1552;
+    AOT_Thread_safepoint_state_offset = 1568;
 static constexpr dart::compiler::target::word
     AOT_Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    AOT_Thread_slow_type_test_entry_point_offset = 640;
+    AOT_Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset =
     56;
 static constexpr dart::compiler::target::word
@@ -9094,11 +9126,11 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word
@@ -9116,19 +9148,19 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_code_offset = 224;
 static constexpr dart::compiler::target::word
-    AOT_Thread_write_barrier_entry_point_offset = 512;
+    AOT_Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_mask_offset = 64;
 static constexpr dart::compiler::target::word AOT_Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word AOT_Thread_callback_code_offset =
-    1560;
+    1576;
 static constexpr dart::compiler::target::word
-    AOT_Thread_callback_stack_return_offset = 1568;
-static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1600;
+    AOT_Thread_callback_stack_return_offset = 1584;
+static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1616;
 static constexpr dart::compiler::target::word
-    AOT_Thread_jump_to_frame_entry_point_offset = 632;
+    AOT_Thread_jump_to_frame_entry_point_offset = 640;
 static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset =
-    1608;
+    1624;
 static constexpr dart::compiler::target::word
     AOT_TsanUtils_setjmp_function_offset = 0;
 static constexpr dart::compiler::target::word
@@ -9212,8 +9244,8 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, -1,   -1,   1448, 1456,
-        1464, 1472, 1480, -1,   1488, 1496, -1,   -1};
+        1432, 1440, 1448, 1456, -1,   -1,   1464, 1472,
+        1480, 1488, 1496, -1,   1504, 1512, -1,   -1};
 static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize =
     24;
 static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 16;
@@ -9574,98 +9606,100 @@
 static constexpr dart::compiler::target::word
     AOT_SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    AOT_Thread_AllocateArray_entry_point_offset = 736;
+    AOT_Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_exception_offset = 1568;
+    AOT_Thread_active_exception_offset = 1584;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_stacktrace_offset = 1576;
+    AOT_Thread_active_stacktrace_offset = 1592;
 static constexpr dart::compiler::target::word
     AOT_Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    AOT_Thread_array_write_barrier_entry_point_offset = 520;
+    AOT_Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_entry_point_offset = 552;
+    AOT_Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_parameterized_entry_point_offset = 560;
+    AOT_Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_slow_entry_point_offset = 568;
+    AOT_Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset =
-    1648;
+    1664;
 static constexpr dart::compiler::target::word
-    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset =
     216;
 static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_to_runtime_entry_point_offset = 528;
+    AOT_Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     AOT_Thread_call_to_runtime_stub_offset = 264;
 static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset =
-    1688;
+    1704;
 static constexpr dart::compiler::target::word
     AOT_Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_truncate_round_supported_offset = 1656;
+    AOT_Thread_double_truncate_round_supported_offset = 1672;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset =
     440;
 static constexpr dart::compiler::target::word
-    AOT_Thread_deoptimize_entry_offset = 616;
+    AOT_Thread_deoptimize_entry_offset = 624;
 static constexpr dart::compiler::target::word
     AOT_Thread_deoptimize_stub_offset = 448;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_abs_address_offset = 696;
+    AOT_Thread_double_abs_address_offset = 704;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_negate_address_offset = 688;
+    AOT_Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word AOT_Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     AOT_Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word
-    AOT_Thread_execution_state_offset = 1608;
+    AOT_Thread_execution_state_offset = 1624;
 static constexpr dart::compiler::target::word
     AOT_Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_stub_offset = 504;
+    AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_entry_point_offset = 624;
+    AOT_Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    AOT_Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_absolute_address_offset = 720;
+    AOT_Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_negate_address_offset = 712;
+    AOT_Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_not_address_offset = 704;
+    AOT_Thread_float_not_address_offset = 712;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_zerow_address_offset = 728;
+    AOT_Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word
-    AOT_Thread_global_object_pool_offset = 1584;
+    AOT_Thread_global_object_pool_offset = 1600;
 static constexpr dart::compiler::target::word
     AOT_Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word
-    AOT_Thread_exit_through_ffi_offset = 1640;
+    AOT_Thread_exit_through_ffi_offset = 1656;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset =
-    1696;
+    1712;
 static constexpr dart::compiler::target::word
     AOT_Thread_field_table_values_offset = 128;
 static constexpr dart::compiler::target::word
@@ -9677,13 +9711,13 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    AOT_Thread_megamorphic_call_checked_entry_offset = 592;
+    AOT_Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    AOT_Thread_switchable_call_miss_entry_offset = 600;
+    AOT_Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     AOT_Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -9708,17 +9742,17 @@
 static constexpr dart::compiler::target::word AOT_Thread_object_null_offset =
     200;
 static constexpr dart::compiler::target::word
-    AOT_Thread_predefined_symbols_address_offset = 672;
+    AOT_Thread_predefined_symbols_address_offset = 680;
 static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset =
-    1592;
+    1608;
 static constexpr dart::compiler::target::word
-    AOT_Thread_saved_shadow_call_stack_offset = 1600;
+    AOT_Thread_saved_shadow_call_stack_offset = 1616;
 static constexpr dart::compiler::target::word
-    AOT_Thread_safepoint_state_offset = 1616;
+    AOT_Thread_safepoint_state_offset = 1632;
 static constexpr dart::compiler::target::word
     AOT_Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    AOT_Thread_slow_type_test_entry_point_offset = 640;
+    AOT_Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset =
     56;
 static constexpr dart::compiler::target::word
@@ -9726,11 +9760,11 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word
@@ -9748,19 +9782,19 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_code_offset = 224;
 static constexpr dart::compiler::target::word
-    AOT_Thread_write_barrier_entry_point_offset = 512;
+    AOT_Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_mask_offset = 64;
 static constexpr dart::compiler::target::word AOT_Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word AOT_Thread_callback_code_offset =
-    1624;
+    1640;
 static constexpr dart::compiler::target::word
-    AOT_Thread_callback_stack_return_offset = 1632;
-static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1664;
+    AOT_Thread_callback_stack_return_offset = 1648;
+static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1680;
 static constexpr dart::compiler::target::word
-    AOT_Thread_jump_to_frame_entry_point_offset = 632;
+    AOT_Thread_jump_to_frame_entry_point_offset = 640;
 static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset =
-    1672;
+    1688;
 static constexpr dart::compiler::target::word
     AOT_TsanUtils_setjmp_function_offset = 0;
 static constexpr dart::compiler::target::word
@@ -9844,9 +9878,9 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496,
-        1504, 1512, 1520, 1528, -1,   -1,   -1,   -1,   1536, 1544, -1,
-        -1,   1552, 1560, 1568, -1,   -1,   -1,   -1,   -1,   -1};
+        1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496, 1504, 1512,
+        1520, 1528, 1536, 1544, -1,   -1,   -1,   -1,   1552, 1560, -1,
+        -1,   1568, 1576, 1584, -1,   -1,   -1,   -1,   -1,   -1};
 static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize =
     24;
 static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 16;
@@ -10202,98 +10236,100 @@
 static constexpr dart::compiler::target::word
     AOT_SubtypeTestCache_cache_offset = 4;
 static constexpr dart::compiler::target::word
-    AOT_Thread_AllocateArray_entry_point_offset = 380;
+    AOT_Thread_AllocateArray_entry_point_offset = 384;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_exception_offset = 752;
+    AOT_Thread_active_exception_offset = 760;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_stacktrace_offset = 756;
+    AOT_Thread_active_stacktrace_offset = 764;
 static constexpr dart::compiler::target::word
     AOT_Thread_array_write_barrier_code_offset = 128;
 static constexpr dart::compiler::target::word
-    AOT_Thread_array_write_barrier_entry_point_offset = 272;
+    AOT_Thread_array_write_barrier_entry_point_offset = 276;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 280;
+    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 284;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 188;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 284;
+    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 288;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 192;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_entry_point_offset = 288;
+    AOT_Thread_allocate_object_entry_point_offset = 292;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_stub_offset = 196;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_parameterized_entry_point_offset = 292;
+    AOT_Thread_allocate_object_parameterized_entry_point_offset = 296;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_parameterized_stub_offset = 200;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_slow_entry_point_offset = 296;
+    AOT_Thread_allocate_object_slow_entry_point_offset = 300;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_slow_stub_offset = 204;
 static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset =
-    792;
+    800;
 static constexpr dart::compiler::target::word
-    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 344;
+    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 348;
 static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset =
     120;
 static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 116;
 static constexpr dart::compiler::target::word
-    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 336;
+    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 340;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_to_runtime_entry_point_offset = 276;
+    AOT_Thread_call_to_runtime_entry_point_offset = 280;
 static constexpr dart::compiler::target::word
     AOT_Thread_call_to_runtime_stub_offset = 144;
 static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset =
-    816;
+    824;
 static constexpr dart::compiler::target::word
     AOT_Thread_dispatch_table_array_offset = 44;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_truncate_round_supported_offset = 796;
+    AOT_Thread_double_truncate_round_supported_offset = 804;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset =
-    316;
+    320;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset =
     232;
 static constexpr dart::compiler::target::word
-    AOT_Thread_deoptimize_entry_offset = 320;
+    AOT_Thread_deoptimize_entry_offset = 324;
 static constexpr dart::compiler::target::word
     AOT_Thread_deoptimize_stub_offset = 236;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_abs_address_offset = 360;
+    AOT_Thread_double_abs_address_offset = 364;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_negate_address_offset = 356;
+    AOT_Thread_double_negate_address_offset = 360;
 static constexpr dart::compiler::target::word AOT_Thread_end_offset = 52;
 static constexpr dart::compiler::target::word
     AOT_Thread_enter_safepoint_stub_offset = 256;
 static constexpr dart::compiler::target::word
-    AOT_Thread_execution_state_offset = 772;
+    AOT_Thread_execution_state_offset = 780;
 static constexpr dart::compiler::target::word
     AOT_Thread_exit_safepoint_stub_offset = 260;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_stub_offset = 264;
+    AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 264;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_entry_point_offset = 324;
+    AOT_Thread_call_native_through_safepoint_stub_offset = 268;
+static constexpr dart::compiler::target::word
+    AOT_Thread_call_native_through_safepoint_entry_point_offset = 328;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_allocation_stub_code_offset = 136;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_callers_target_code_offset = 132;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_absolute_address_offset = 372;
+    AOT_Thread_float_absolute_address_offset = 376;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_negate_address_offset = 368;
+    AOT_Thread_float_negate_address_offset = 372;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_not_address_offset = 364;
+    AOT_Thread_float_not_address_offset = 368;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_zerow_address_offset = 376;
+    AOT_Thread_float_zerow_address_offset = 380;
 static constexpr dart::compiler::target::word
-    AOT_Thread_global_object_pool_offset = 760;
+    AOT_Thread_global_object_pool_offset = 768;
 static constexpr dart::compiler::target::word
     AOT_Thread_invoke_dart_code_stub_offset = 140;
 static constexpr dart::compiler::target::word
-    AOT_Thread_exit_through_ffi_offset = 788;
+    AOT_Thread_exit_through_ffi_offset = 796;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 40;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset =
-    820;
+    828;
 static constexpr dart::compiler::target::word
     AOT_Thread_field_table_values_offset = 64;
 static constexpr dart::compiler::target::word
@@ -10305,13 +10341,13 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_marking_stack_block_offset = 80;
 static constexpr dart::compiler::target::word
-    AOT_Thread_megamorphic_call_checked_entry_offset = 308;
+    AOT_Thread_megamorphic_call_checked_entry_offset = 312;
 static constexpr dart::compiler::target::word
-    AOT_Thread_switchable_call_miss_entry_offset = 312;
+    AOT_Thread_switchable_call_miss_entry_offset = 316;
 static constexpr dart::compiler::target::word
     AOT_Thread_switchable_call_miss_stub_offset = 216;
 static constexpr dart::compiler::target::word
-    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 340;
+    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 344;
 static constexpr dart::compiler::target::word
     AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 152;
 static constexpr dart::compiler::target::word
@@ -10336,16 +10372,16 @@
 static constexpr dart::compiler::target::word AOT_Thread_object_null_offset =
     112;
 static constexpr dart::compiler::target::word
-    AOT_Thread_predefined_symbols_address_offset = 348;
-static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = 764;
+    AOT_Thread_predefined_symbols_address_offset = 352;
+static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = 772;
 static constexpr dart::compiler::target::word
-    AOT_Thread_saved_shadow_call_stack_offset = 768;
+    AOT_Thread_saved_shadow_call_stack_offset = 776;
 static constexpr dart::compiler::target::word
-    AOT_Thread_safepoint_state_offset = 776;
+    AOT_Thread_safepoint_state_offset = 784;
 static constexpr dart::compiler::target::word
     AOT_Thread_slow_type_test_stub_offset = 248;
 static constexpr dart::compiler::target::word
-    AOT_Thread_slow_type_test_entry_point_offset = 332;
+    AOT_Thread_slow_type_test_entry_point_offset = 336;
 static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset =
     28;
 static constexpr dart::compiler::target::word
@@ -10353,11 +10389,11 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_flags_offset = 60;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 304;
+    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 308;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 212;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 300;
+    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 304;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 208;
 static constexpr dart::compiler::target::word
@@ -10375,19 +10411,19 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_code_offset = 124;
 static constexpr dart::compiler::target::word
-    AOT_Thread_write_barrier_entry_point_offset = 268;
+    AOT_Thread_write_barrier_entry_point_offset = 272;
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_mask_offset = 32;
 static constexpr dart::compiler::target::word AOT_Thread_heap_base_offset = 36;
 static constexpr dart::compiler::target::word AOT_Thread_callback_code_offset =
-    780;
+    788;
 static constexpr dart::compiler::target::word
-    AOT_Thread_callback_stack_return_offset = 784;
-static constexpr dart::compiler::target::word AOT_Thread_random_offset = 800;
+    AOT_Thread_callback_stack_return_offset = 792;
+static constexpr dart::compiler::target::word AOT_Thread_random_offset = 808;
 static constexpr dart::compiler::target::word
-    AOT_Thread_jump_to_frame_entry_point_offset = 328;
+    AOT_Thread_jump_to_frame_entry_point_offset = 332;
 static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset =
-    808;
+    816;
 static constexpr dart::compiler::target::word
     AOT_TsanUtils_setjmp_function_offset = 0;
 static constexpr dart::compiler::target::word
@@ -10470,7 +10506,7 @@
     4, 12, 8, 16};
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_wrappers_thread_offset[] = {
-        720, 724, 728, 732, 736, -1, 740, -1, 744, 748, -1, -1, -1, -1, -1, -1};
+        728, 732, 736, 740, 744, -1, 748, -1, 752, 756, -1, -1, -1, -1, -1, -1};
 static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize =
     12;
 static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 8;
@@ -10825,98 +10861,100 @@
 static constexpr dart::compiler::target::word
     AOT_SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    AOT_Thread_AllocateArray_entry_point_offset = 736;
+    AOT_Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_exception_offset = 1504;
+    AOT_Thread_active_exception_offset = 1520;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_stacktrace_offset = 1512;
+    AOT_Thread_active_stacktrace_offset = 1528;
 static constexpr dart::compiler::target::word
     AOT_Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    AOT_Thread_array_write_barrier_entry_point_offset = 520;
+    AOT_Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_entry_point_offset = 552;
+    AOT_Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_parameterized_entry_point_offset = 560;
+    AOT_Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_slow_entry_point_offset = 568;
+    AOT_Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset =
-    1584;
+    1600;
 static constexpr dart::compiler::target::word
-    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset =
     216;
 static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_to_runtime_entry_point_offset = 528;
+    AOT_Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     AOT_Thread_call_to_runtime_stub_offset = 264;
 static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset =
-    1624;
+    1640;
 static constexpr dart::compiler::target::word
     AOT_Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_truncate_round_supported_offset = 1592;
+    AOT_Thread_double_truncate_round_supported_offset = 1608;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset =
     440;
 static constexpr dart::compiler::target::word
-    AOT_Thread_deoptimize_entry_offset = 616;
+    AOT_Thread_deoptimize_entry_offset = 624;
 static constexpr dart::compiler::target::word
     AOT_Thread_deoptimize_stub_offset = 448;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_abs_address_offset = 696;
+    AOT_Thread_double_abs_address_offset = 704;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_negate_address_offset = 688;
+    AOT_Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word AOT_Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     AOT_Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word
-    AOT_Thread_execution_state_offset = 1544;
+    AOT_Thread_execution_state_offset = 1560;
 static constexpr dart::compiler::target::word
     AOT_Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_stub_offset = 504;
+    AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_entry_point_offset = 624;
+    AOT_Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    AOT_Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_absolute_address_offset = 720;
+    AOT_Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_negate_address_offset = 712;
+    AOT_Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_not_address_offset = 704;
+    AOT_Thread_float_not_address_offset = 712;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_zerow_address_offset = 728;
+    AOT_Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word
-    AOT_Thread_global_object_pool_offset = 1520;
+    AOT_Thread_global_object_pool_offset = 1536;
 static constexpr dart::compiler::target::word
     AOT_Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word
-    AOT_Thread_exit_through_ffi_offset = 1576;
+    AOT_Thread_exit_through_ffi_offset = 1592;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset =
-    1632;
+    1648;
 static constexpr dart::compiler::target::word
     AOT_Thread_field_table_values_offset = 128;
 static constexpr dart::compiler::target::word
@@ -10928,13 +10966,13 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    AOT_Thread_megamorphic_call_checked_entry_offset = 592;
+    AOT_Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    AOT_Thread_switchable_call_miss_entry_offset = 600;
+    AOT_Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     AOT_Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -10959,17 +10997,17 @@
 static constexpr dart::compiler::target::word AOT_Thread_object_null_offset =
     200;
 static constexpr dart::compiler::target::word
-    AOT_Thread_predefined_symbols_address_offset = 672;
+    AOT_Thread_predefined_symbols_address_offset = 680;
 static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset =
-    1528;
+    1544;
 static constexpr dart::compiler::target::word
-    AOT_Thread_saved_shadow_call_stack_offset = 1536;
+    AOT_Thread_saved_shadow_call_stack_offset = 1552;
 static constexpr dart::compiler::target::word
-    AOT_Thread_safepoint_state_offset = 1552;
+    AOT_Thread_safepoint_state_offset = 1568;
 static constexpr dart::compiler::target::word
     AOT_Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    AOT_Thread_slow_type_test_entry_point_offset = 640;
+    AOT_Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset =
     56;
 static constexpr dart::compiler::target::word
@@ -10977,11 +11015,11 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word
@@ -10999,19 +11037,19 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_code_offset = 224;
 static constexpr dart::compiler::target::word
-    AOT_Thread_write_barrier_entry_point_offset = 512;
+    AOT_Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_mask_offset = 64;
 static constexpr dart::compiler::target::word AOT_Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word AOT_Thread_callback_code_offset =
-    1560;
+    1576;
 static constexpr dart::compiler::target::word
-    AOT_Thread_callback_stack_return_offset = 1568;
-static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1600;
+    AOT_Thread_callback_stack_return_offset = 1584;
+static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1616;
 static constexpr dart::compiler::target::word
-    AOT_Thread_jump_to_frame_entry_point_offset = 632;
+    AOT_Thread_jump_to_frame_entry_point_offset = 640;
 static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset =
-    1608;
+    1624;
 static constexpr dart::compiler::target::word
     AOT_TsanUtils_setjmp_function_offset = 0;
 static constexpr dart::compiler::target::word
@@ -11095,8 +11133,8 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, -1,   -1,   1448, 1456,
-        1464, 1472, 1480, -1,   1488, 1496, -1,   -1};
+        1432, 1440, 1448, 1456, -1,   -1,   1464, 1472,
+        1480, 1488, 1496, -1,   1504, 1512, -1,   -1};
 static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize =
     24;
 static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 16;
@@ -11454,98 +11492,100 @@
 static constexpr dart::compiler::target::word
     AOT_SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    AOT_Thread_AllocateArray_entry_point_offset = 736;
+    AOT_Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_exception_offset = 1568;
+    AOT_Thread_active_exception_offset = 1584;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_stacktrace_offset = 1576;
+    AOT_Thread_active_stacktrace_offset = 1592;
 static constexpr dart::compiler::target::word
     AOT_Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    AOT_Thread_array_write_barrier_entry_point_offset = 520;
+    AOT_Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_entry_point_offset = 552;
+    AOT_Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_parameterized_entry_point_offset = 560;
+    AOT_Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_slow_entry_point_offset = 568;
+    AOT_Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset =
-    1648;
+    1664;
 static constexpr dart::compiler::target::word
-    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset =
     216;
 static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_to_runtime_entry_point_offset = 528;
+    AOT_Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     AOT_Thread_call_to_runtime_stub_offset = 264;
 static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset =
-    1688;
+    1704;
 static constexpr dart::compiler::target::word
     AOT_Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_truncate_round_supported_offset = 1656;
+    AOT_Thread_double_truncate_round_supported_offset = 1672;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset =
     440;
 static constexpr dart::compiler::target::word
-    AOT_Thread_deoptimize_entry_offset = 616;
+    AOT_Thread_deoptimize_entry_offset = 624;
 static constexpr dart::compiler::target::word
     AOT_Thread_deoptimize_stub_offset = 448;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_abs_address_offset = 696;
+    AOT_Thread_double_abs_address_offset = 704;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_negate_address_offset = 688;
+    AOT_Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word AOT_Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     AOT_Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word
-    AOT_Thread_execution_state_offset = 1608;
+    AOT_Thread_execution_state_offset = 1624;
 static constexpr dart::compiler::target::word
     AOT_Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_stub_offset = 504;
+    AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_entry_point_offset = 624;
+    AOT_Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    AOT_Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_absolute_address_offset = 720;
+    AOT_Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_negate_address_offset = 712;
+    AOT_Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_not_address_offset = 704;
+    AOT_Thread_float_not_address_offset = 712;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_zerow_address_offset = 728;
+    AOT_Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word
-    AOT_Thread_global_object_pool_offset = 1584;
+    AOT_Thread_global_object_pool_offset = 1600;
 static constexpr dart::compiler::target::word
     AOT_Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word
-    AOT_Thread_exit_through_ffi_offset = 1640;
+    AOT_Thread_exit_through_ffi_offset = 1656;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset =
-    1696;
+    1712;
 static constexpr dart::compiler::target::word
     AOT_Thread_field_table_values_offset = 128;
 static constexpr dart::compiler::target::word
@@ -11557,13 +11597,13 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    AOT_Thread_megamorphic_call_checked_entry_offset = 592;
+    AOT_Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    AOT_Thread_switchable_call_miss_entry_offset = 600;
+    AOT_Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     AOT_Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -11588,17 +11628,17 @@
 static constexpr dart::compiler::target::word AOT_Thread_object_null_offset =
     200;
 static constexpr dart::compiler::target::word
-    AOT_Thread_predefined_symbols_address_offset = 672;
+    AOT_Thread_predefined_symbols_address_offset = 680;
 static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset =
-    1592;
+    1608;
 static constexpr dart::compiler::target::word
-    AOT_Thread_saved_shadow_call_stack_offset = 1600;
+    AOT_Thread_saved_shadow_call_stack_offset = 1616;
 static constexpr dart::compiler::target::word
-    AOT_Thread_safepoint_state_offset = 1616;
+    AOT_Thread_safepoint_state_offset = 1632;
 static constexpr dart::compiler::target::word
     AOT_Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    AOT_Thread_slow_type_test_entry_point_offset = 640;
+    AOT_Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset =
     56;
 static constexpr dart::compiler::target::word
@@ -11606,11 +11646,11 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word
@@ -11628,19 +11668,19 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_code_offset = 224;
 static constexpr dart::compiler::target::word
-    AOT_Thread_write_barrier_entry_point_offset = 512;
+    AOT_Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_mask_offset = 64;
 static constexpr dart::compiler::target::word AOT_Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word AOT_Thread_callback_code_offset =
-    1624;
+    1640;
 static constexpr dart::compiler::target::word
-    AOT_Thread_callback_stack_return_offset = 1632;
-static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1664;
+    AOT_Thread_callback_stack_return_offset = 1648;
+static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1680;
 static constexpr dart::compiler::target::word
-    AOT_Thread_jump_to_frame_entry_point_offset = 632;
+    AOT_Thread_jump_to_frame_entry_point_offset = 640;
 static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset =
-    1672;
+    1688;
 static constexpr dart::compiler::target::word
     AOT_TsanUtils_setjmp_function_offset = 0;
 static constexpr dart::compiler::target::word
@@ -11724,9 +11764,9 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496,
-        1504, 1512, 1520, 1528, -1,   -1,   -1,   -1,   1536, 1544, -1,
-        -1,   1552, 1560, 1568, -1,   -1,   -1,   -1,   -1,   -1};
+        1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496, 1504, 1512,
+        1520, 1528, 1536, 1544, -1,   -1,   -1,   -1,   1552, 1560, -1,
+        -1,   1568, 1576, 1584, -1,   -1,   -1,   -1,   -1,   -1};
 static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize =
     24;
 static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 16;
@@ -12080,98 +12120,100 @@
 static constexpr dart::compiler::target::word
     AOT_SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    AOT_Thread_AllocateArray_entry_point_offset = 736;
+    AOT_Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_exception_offset = 1504;
+    AOT_Thread_active_exception_offset = 1520;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_stacktrace_offset = 1512;
+    AOT_Thread_active_stacktrace_offset = 1528;
 static constexpr dart::compiler::target::word
     AOT_Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    AOT_Thread_array_write_barrier_entry_point_offset = 520;
+    AOT_Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_entry_point_offset = 552;
+    AOT_Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_parameterized_entry_point_offset = 560;
+    AOT_Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_slow_entry_point_offset = 568;
+    AOT_Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset =
-    1584;
+    1600;
 static constexpr dart::compiler::target::word
-    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset =
     216;
 static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_to_runtime_entry_point_offset = 528;
+    AOT_Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     AOT_Thread_call_to_runtime_stub_offset = 264;
 static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset =
-    1624;
+    1640;
 static constexpr dart::compiler::target::word
     AOT_Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_truncate_round_supported_offset = 1592;
+    AOT_Thread_double_truncate_round_supported_offset = 1608;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset =
     440;
 static constexpr dart::compiler::target::word
-    AOT_Thread_deoptimize_entry_offset = 616;
+    AOT_Thread_deoptimize_entry_offset = 624;
 static constexpr dart::compiler::target::word
     AOT_Thread_deoptimize_stub_offset = 448;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_abs_address_offset = 696;
+    AOT_Thread_double_abs_address_offset = 704;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_negate_address_offset = 688;
+    AOT_Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word AOT_Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     AOT_Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word
-    AOT_Thread_execution_state_offset = 1544;
+    AOT_Thread_execution_state_offset = 1560;
 static constexpr dart::compiler::target::word
     AOT_Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_stub_offset = 504;
+    AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_entry_point_offset = 624;
+    AOT_Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    AOT_Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_absolute_address_offset = 720;
+    AOT_Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_negate_address_offset = 712;
+    AOT_Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_not_address_offset = 704;
+    AOT_Thread_float_not_address_offset = 712;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_zerow_address_offset = 728;
+    AOT_Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word
-    AOT_Thread_global_object_pool_offset = 1520;
+    AOT_Thread_global_object_pool_offset = 1536;
 static constexpr dart::compiler::target::word
     AOT_Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word
-    AOT_Thread_exit_through_ffi_offset = 1576;
+    AOT_Thread_exit_through_ffi_offset = 1592;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset =
-    1632;
+    1648;
 static constexpr dart::compiler::target::word
     AOT_Thread_field_table_values_offset = 128;
 static constexpr dart::compiler::target::word
@@ -12183,13 +12225,13 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    AOT_Thread_megamorphic_call_checked_entry_offset = 592;
+    AOT_Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    AOT_Thread_switchable_call_miss_entry_offset = 600;
+    AOT_Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     AOT_Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -12214,17 +12256,17 @@
 static constexpr dart::compiler::target::word AOT_Thread_object_null_offset =
     200;
 static constexpr dart::compiler::target::word
-    AOT_Thread_predefined_symbols_address_offset = 672;
+    AOT_Thread_predefined_symbols_address_offset = 680;
 static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset =
-    1528;
+    1544;
 static constexpr dart::compiler::target::word
-    AOT_Thread_saved_shadow_call_stack_offset = 1536;
+    AOT_Thread_saved_shadow_call_stack_offset = 1552;
 static constexpr dart::compiler::target::word
-    AOT_Thread_safepoint_state_offset = 1552;
+    AOT_Thread_safepoint_state_offset = 1568;
 static constexpr dart::compiler::target::word
     AOT_Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    AOT_Thread_slow_type_test_entry_point_offset = 640;
+    AOT_Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset =
     56;
 static constexpr dart::compiler::target::word
@@ -12232,11 +12274,11 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word
@@ -12254,19 +12296,19 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_code_offset = 224;
 static constexpr dart::compiler::target::word
-    AOT_Thread_write_barrier_entry_point_offset = 512;
+    AOT_Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_mask_offset = 64;
 static constexpr dart::compiler::target::word AOT_Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word AOT_Thread_callback_code_offset =
-    1560;
+    1576;
 static constexpr dart::compiler::target::word
-    AOT_Thread_callback_stack_return_offset = 1568;
-static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1600;
+    AOT_Thread_callback_stack_return_offset = 1584;
+static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1616;
 static constexpr dart::compiler::target::word
-    AOT_Thread_jump_to_frame_entry_point_offset = 632;
+    AOT_Thread_jump_to_frame_entry_point_offset = 640;
 static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset =
-    1608;
+    1624;
 static constexpr dart::compiler::target::word
     AOT_TsanUtils_setjmp_function_offset = 0;
 static constexpr dart::compiler::target::word
@@ -12350,8 +12392,8 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, -1,   -1,   1448, 1456,
-        1464, 1472, 1480, -1,   1488, 1496, -1,   -1};
+        1432, 1440, 1448, 1456, -1,   -1,   1464, 1472,
+        1480, 1488, 1496, -1,   1504, 1512, -1,   -1};
 static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize =
     24;
 static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 16;
@@ -12705,98 +12747,100 @@
 static constexpr dart::compiler::target::word
     AOT_SubtypeTestCache_cache_offset = 8;
 static constexpr dart::compiler::target::word
-    AOT_Thread_AllocateArray_entry_point_offset = 736;
+    AOT_Thread_AllocateArray_entry_point_offset = 744;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_exception_offset = 1568;
+    AOT_Thread_active_exception_offset = 1584;
 static constexpr dart::compiler::target::word
-    AOT_Thread_active_stacktrace_offset = 1576;
+    AOT_Thread_active_stacktrace_offset = 1592;
 static constexpr dart::compiler::target::word
     AOT_Thread_array_write_barrier_code_offset = 232;
 static constexpr dart::compiler::target::word
-    AOT_Thread_array_write_barrier_entry_point_offset = 520;
+    AOT_Thread_array_write_barrier_entry_point_offset = 528;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 536;
+    AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 544;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 352;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 544;
+    AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 552;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 360;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_entry_point_offset = 552;
+    AOT_Thread_allocate_object_entry_point_offset = 560;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_stub_offset = 368;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_parameterized_entry_point_offset = 560;
+    AOT_Thread_allocate_object_parameterized_entry_point_offset = 568;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_parameterized_stub_offset = 376;
 static constexpr dart::compiler::target::word
-    AOT_Thread_allocate_object_slow_entry_point_offset = 568;
+    AOT_Thread_allocate_object_slow_entry_point_offset = 576;
 static constexpr dart::compiler::target::word
     AOT_Thread_allocate_object_slow_stub_offset = 384;
 static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset =
-    1648;
+    1664;
 static constexpr dart::compiler::target::word
-    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 664;
+    AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 672;
 static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset =
     216;
 static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 208;
 static constexpr dart::compiler::target::word
-    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 648;
+    AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 656;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_to_runtime_entry_point_offset = 528;
+    AOT_Thread_call_to_runtime_entry_point_offset = 536;
 static constexpr dart::compiler::target::word
     AOT_Thread_call_to_runtime_stub_offset = 264;
 static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset =
-    1688;
+    1704;
 static constexpr dart::compiler::target::word
     AOT_Thread_dispatch_table_array_offset = 88;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_truncate_round_supported_offset = 1656;
+    AOT_Thread_double_truncate_round_supported_offset = 1672;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset =
-    608;
+    616;
 static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset =
     440;
 static constexpr dart::compiler::target::word
-    AOT_Thread_deoptimize_entry_offset = 616;
+    AOT_Thread_deoptimize_entry_offset = 624;
 static constexpr dart::compiler::target::word
     AOT_Thread_deoptimize_stub_offset = 448;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_abs_address_offset = 696;
+    AOT_Thread_double_abs_address_offset = 704;
 static constexpr dart::compiler::target::word
-    AOT_Thread_double_negate_address_offset = 688;
+    AOT_Thread_double_negate_address_offset = 696;
 static constexpr dart::compiler::target::word AOT_Thread_end_offset = 104;
 static constexpr dart::compiler::target::word
     AOT_Thread_enter_safepoint_stub_offset = 488;
 static constexpr dart::compiler::target::word
-    AOT_Thread_execution_state_offset = 1608;
+    AOT_Thread_execution_state_offset = 1624;
 static constexpr dart::compiler::target::word
     AOT_Thread_exit_safepoint_stub_offset = 496;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_stub_offset = 504;
+    AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 504;
 static constexpr dart::compiler::target::word
-    AOT_Thread_call_native_through_safepoint_entry_point_offset = 624;
+    AOT_Thread_call_native_through_safepoint_stub_offset = 512;
+static constexpr dart::compiler::target::word
+    AOT_Thread_call_native_through_safepoint_entry_point_offset = 632;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_allocation_stub_code_offset = 248;
 static constexpr dart::compiler::target::word
     AOT_Thread_fix_callers_target_code_offset = 240;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_absolute_address_offset = 720;
+    AOT_Thread_float_absolute_address_offset = 728;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_negate_address_offset = 712;
+    AOT_Thread_float_negate_address_offset = 720;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_not_address_offset = 704;
+    AOT_Thread_float_not_address_offset = 712;
 static constexpr dart::compiler::target::word
-    AOT_Thread_float_zerow_address_offset = 728;
+    AOT_Thread_float_zerow_address_offset = 736;
 static constexpr dart::compiler::target::word
-    AOT_Thread_global_object_pool_offset = 1584;
+    AOT_Thread_global_object_pool_offset = 1600;
 static constexpr dart::compiler::target::word
     AOT_Thread_invoke_dart_code_stub_offset = 256;
 static constexpr dart::compiler::target::word
-    AOT_Thread_exit_through_ffi_offset = 1640;
+    AOT_Thread_exit_through_ffi_offset = 1656;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 80;
 static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset =
-    1696;
+    1712;
 static constexpr dart::compiler::target::word
     AOT_Thread_field_table_values_offset = 128;
 static constexpr dart::compiler::target::word
@@ -12808,13 +12852,13 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_marking_stack_block_offset = 160;
 static constexpr dart::compiler::target::word
-    AOT_Thread_megamorphic_call_checked_entry_offset = 592;
+    AOT_Thread_megamorphic_call_checked_entry_offset = 600;
 static constexpr dart::compiler::target::word
-    AOT_Thread_switchable_call_miss_entry_offset = 600;
+    AOT_Thread_switchable_call_miss_entry_offset = 608;
 static constexpr dart::compiler::target::word
     AOT_Thread_switchable_call_miss_stub_offset = 408;
 static constexpr dart::compiler::target::word
-    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 656;
+    AOT_Thread_no_scope_native_wrapper_entry_point_offset = 664;
 static constexpr dart::compiler::target::word
     AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 280;
 static constexpr dart::compiler::target::word
@@ -12839,17 +12883,17 @@
 static constexpr dart::compiler::target::word AOT_Thread_object_null_offset =
     200;
 static constexpr dart::compiler::target::word
-    AOT_Thread_predefined_symbols_address_offset = 672;
+    AOT_Thread_predefined_symbols_address_offset = 680;
 static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset =
-    1592;
+    1608;
 static constexpr dart::compiler::target::word
-    AOT_Thread_saved_shadow_call_stack_offset = 1600;
+    AOT_Thread_saved_shadow_call_stack_offset = 1616;
 static constexpr dart::compiler::target::word
-    AOT_Thread_safepoint_state_offset = 1616;
+    AOT_Thread_safepoint_state_offset = 1632;
 static constexpr dart::compiler::target::word
     AOT_Thread_slow_type_test_stub_offset = 472;
 static constexpr dart::compiler::target::word
-    AOT_Thread_slow_type_test_entry_point_offset = 640;
+    AOT_Thread_slow_type_test_entry_point_offset = 648;
 static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset =
     56;
 static constexpr dart::compiler::target::word
@@ -12857,11 +12901,11 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_flags_offset = 120;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 584;
+    AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 592;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 400;
 static constexpr dart::compiler::target::word
-    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 576;
+    AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 584;
 static constexpr dart::compiler::target::word
     AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 392;
 static constexpr dart::compiler::target::word
@@ -12879,19 +12923,19 @@
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_code_offset = 224;
 static constexpr dart::compiler::target::word
-    AOT_Thread_write_barrier_entry_point_offset = 512;
+    AOT_Thread_write_barrier_entry_point_offset = 520;
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_mask_offset = 64;
 static constexpr dart::compiler::target::word AOT_Thread_heap_base_offset = 72;
 static constexpr dart::compiler::target::word AOT_Thread_callback_code_offset =
-    1624;
+    1640;
 static constexpr dart::compiler::target::word
-    AOT_Thread_callback_stack_return_offset = 1632;
-static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1664;
+    AOT_Thread_callback_stack_return_offset = 1648;
+static constexpr dart::compiler::target::word AOT_Thread_random_offset = 1680;
 static constexpr dart::compiler::target::word
-    AOT_Thread_jump_to_frame_entry_point_offset = 632;
+    AOT_Thread_jump_to_frame_entry_point_offset = 640;
 static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset =
-    1672;
+    1688;
 static constexpr dart::compiler::target::word
     AOT_TsanUtils_setjmp_function_offset = 0;
 static constexpr dart::compiler::target::word
@@ -12975,9 +13019,9 @@
     8, 24, 16, 32};
 static constexpr dart::compiler::target::word
     AOT_Thread_write_barrier_wrappers_thread_offset[] = {
-        1416, 1424, 1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496,
-        1504, 1512, 1520, 1528, -1,   -1,   -1,   -1,   1536, 1544, -1,
-        -1,   1552, 1560, 1568, -1,   -1,   -1,   -1,   -1,   -1};
+        1432, 1440, 1448, 1456, 1464, 1472, 1480, 1488, 1496, 1504, 1512,
+        1520, 1528, 1536, 1544, -1,   -1,   -1,   -1,   1552, 1560, -1,
+        -1,   1568, 1576, 1584, -1,   -1,   -1,   -1,   -1,   -1};
 static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize =
     24;
 static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 16;
diff --git a/runtime/vm/compiler/runtime_offsets_list.h b/runtime/vm/compiler/runtime_offsets_list.h
index e252e4d..1883b9d 100644
--- a/runtime/vm/compiler/runtime_offsets_list.h
+++ b/runtime/vm/compiler/runtime_offsets_list.h
@@ -223,6 +223,7 @@
   FIELD(Thread, enter_safepoint_stub_offset)                                   \
   FIELD(Thread, execution_state_offset)                                        \
   FIELD(Thread, exit_safepoint_stub_offset)                                    \
+  FIELD(Thread, exit_safepoint_ignore_unwind_in_progress_stub_offset)          \
   FIELD(Thread, call_native_through_safepoint_stub_offset)                     \
   FIELD(Thread, call_native_through_safepoint_entry_point_offset)              \
   FIELD(Thread, fix_allocation_stub_code_offset)                               \
diff --git a/runtime/vm/compiler/stub_code_compiler_arm.cc b/runtime/vm/compiler/stub_code_compiler_arm.cc
index e31e943..602dfb2 100644
--- a/runtime/vm/compiler/stub_code_compiler_arm.cc
+++ b/runtime/vm/compiler/stub_code_compiler_arm.cc
@@ -318,7 +318,8 @@
   __ Ret();
 }
 
-void StubCodeCompiler::GenerateExitSafepointStub(Assembler* assembler) {
+static void GenerateExitSafepointStubCommon(Assembler* assembler,
+                                            uword runtime_entry_offset) {
   RegisterSet all_registers;
   all_registers.AddAllGeneralRegisters();
   __ PushRegisters(all_registers);
@@ -332,7 +333,7 @@
   __ LoadImmediate(R0, target::Thread::vm_execution_state());
   __ str(R0, Address(THR, target::Thread::execution_state_offset()));
 
-  __ ldr(R0, Address(THR, kExitSafepointRuntimeEntry.OffsetFromThread()));
+  __ ldr(R0, Address(THR, runtime_entry_offset));
   __ blx(R0);
   RESTORES_LR_FROM_FRAME(__ LeaveFrame((1 << FP) | (1 << LR), 0));
 
@@ -340,6 +341,18 @@
   __ Ret();
 }
 
+void StubCodeCompiler::GenerateExitSafepointStub(Assembler* assembler) {
+  GenerateExitSafepointStubCommon(
+      assembler, kExitSafepointRuntimeEntry.OffsetFromThread());
+}
+
+void StubCodeCompiler::GenerateExitSafepointIgnoreUnwindInProgressStub(
+    Assembler* assembler) {
+  GenerateExitSafepointStubCommon(
+      assembler,
+      kExitSafepointIgnoreUnwindInProgressRuntimeEntry.OffsetFromThread());
+}
+
 // Call a native function within a safepoint.
 //
 // On entry:
@@ -2896,14 +2909,20 @@
 #endif
   Label exit_through_non_ffi;
   Register tmp1 = R0, tmp2 = R1;
-  // Check if we exited generated from FFI. If so do transition.
+  // Check if we exited generated from FFI. If so do transition - this is needed
+  // because normally runtime calls transition back to generated via destructor
+  // of TransititionGeneratedToVM/Native that is part of runtime boilerplate
+  // code (see DEFINE_RUNTIME_ENTRY_IMPL in runtime_entry.h). Ffi calls don't
+  // have this boilerplate, don't have this stack resource, have to transition
+  // explicitly.
   __ LoadFromOffset(tmp1, THR,
                     compiler::target::Thread::exit_through_ffi_offset());
   __ LoadImmediate(tmp2, target::Thread::exit_through_ffi());
   __ cmp(tmp1, Operand(tmp2));
   __ b(&exit_through_non_ffi, NE);
   __ TransitionNativeToGenerated(tmp1, tmp2,
-                                 /*leave_safepoint=*/true);
+                                 /*leave_safepoint=*/true,
+                                 /*ignore_unwind_in_progress=*/true);
   __ Bind(&exit_through_non_ffi);
 
   // Set the tag.
diff --git a/runtime/vm/compiler/stub_code_compiler_arm64.cc b/runtime/vm/compiler/stub_code_compiler_arm64.cc
index af8d3c5..bcdc1f4 100644
--- a/runtime/vm/compiler/stub_code_compiler_arm64.cc
+++ b/runtime/vm/compiler/stub_code_compiler_arm64.cc
@@ -250,7 +250,8 @@
   __ Ret();
 }
 
-void StubCodeCompiler::GenerateExitSafepointStub(Assembler* assembler) {
+static void GenerateExitSafepointStubCommon(Assembler* assembler,
+                                            uword runtime_entry_offset) {
   RegisterSet all_registers;
   all_registers.AddAllGeneralRegisters();
 
@@ -268,7 +269,7 @@
   __ LoadImmediate(R0, target::Thread::vm_execution_state());
   __ str(R0, Address(THR, target::Thread::execution_state_offset()));
 
-  __ ldr(R0, Address(THR, kExitSafepointRuntimeEntry.OffsetFromThread()));
+  __ ldr(R0, Address(THR, runtime_entry_offset));
   __ blr(R0);
 
   __ mov(SP, CALLEE_SAVED_TEMP2);
@@ -280,6 +281,18 @@
   __ Ret();
 }
 
+void StubCodeCompiler::GenerateExitSafepointStub(Assembler* assembler) {
+  GenerateExitSafepointStubCommon(
+      assembler, kExitSafepointRuntimeEntry.OffsetFromThread());
+}
+
+void StubCodeCompiler::GenerateExitSafepointIgnoreUnwindInProgressStub(
+    Assembler* assembler) {
+  GenerateExitSafepointStubCommon(
+      assembler,
+      kExitSafepointIgnoreUnwindInProgressRuntimeEntry.OffsetFromThread());
+}
+
 // Calls native code within a safepoint.
 //
 // On entry:
@@ -3092,13 +3105,19 @@
 #endif
   Label exit_through_non_ffi;
   Register tmp1 = R0, tmp2 = R1;
-  // Check if we exited generated from FFI. If so do transition.
+  // Check if we exited generated from FFI. If so do transition - this is needed
+  // because normally runtime calls transition back to generated via destructor
+  // of TransititionGeneratedToVM/Native that is part of runtime boilerplate
+  // code (see DEFINE_RUNTIME_ENTRY_IMPL in runtime_entry.h). Ffi calls don't
+  // have this boilerplate, don't have this stack resource, have to transition
+  // explicitly.
   __ LoadFromOffset(tmp1, THR,
                     compiler::target::Thread::exit_through_ffi_offset());
   __ LoadImmediate(tmp2, target::Thread::exit_through_ffi());
   __ cmp(tmp1, Operand(tmp2));
   __ b(&exit_through_non_ffi, NE);
-  __ TransitionNativeToGenerated(tmp1, /*leave_safepoint=*/true);
+  __ TransitionNativeToGenerated(tmp1, /*leave_safepoint=*/true,
+                                 /*ignore_unwind_in_progress=*/true);
   __ Bind(&exit_through_non_ffi);
 
   // Refresh pinned registers values (inc. write barrier mask and null object).
diff --git a/runtime/vm/compiler/stub_code_compiler_ia32.cc b/runtime/vm/compiler/stub_code_compiler_ia32.cc
index 654e0ef..e75588c 100644
--- a/runtime/vm/compiler/stub_code_compiler_ia32.cc
+++ b/runtime/vm/compiler/stub_code_compiler_ia32.cc
@@ -157,7 +157,8 @@
   __ ret();
 }
 
-void StubCodeCompiler::GenerateExitSafepointStub(Assembler* assembler) {
+static void GenerateExitSafepointStubCommon(Assembler* assembler,
+                                            uword runtime_entry_offset) {
   __ pushal();
   __ subl(SPREG, Immediate(8));
   __ movsd(Address(SPREG, 0), XMM0);
@@ -171,7 +172,7 @@
   __ movl(Address(THR, target::Thread::execution_state_offset()),
           Immediate(target::Thread::vm_execution_state()));
 
-  __ movl(EAX, Address(THR, kExitSafepointRuntimeEntry.OffsetFromThread()));
+  __ movl(EAX, Address(THR, runtime_entry_offset));
   __ call(EAX);
   __ LeaveFrame();
 
@@ -181,6 +182,18 @@
   __ ret();
 }
 
+void StubCodeCompiler::GenerateExitSafepointStub(Assembler* assembler) {
+  GenerateExitSafepointStubCommon(
+      assembler, kExitSafepointRuntimeEntry.OffsetFromThread());
+}
+
+void StubCodeCompiler::GenerateExitSafepointIgnoreUnwindInProgressStub(
+    Assembler* assembler) {
+  GenerateExitSafepointStubCommon(
+      assembler,
+      kExitSafepointIgnoreUnwindInProgressRuntimeEntry.OffsetFromThread());
+}
+
 // Calls a native function inside a safepoint.
 //
 // On entry:
@@ -2527,12 +2540,18 @@
 #endif
 
   Label exit_through_non_ffi;
-  // Check if we exited generated from FFI. If so do transition.
+  // Check if we exited generated from FFI. If so do transition - this is needed
+  // because normally runtime calls transition back to generated via destructor
+  // of TransititionGeneratedToVM/Native that is part of runtime boilerplate
+  // code (see DEFINE_RUNTIME_ENTRY_IMPL in runtime_entry.h). Ffi calls don't
+  // have this boilerplate, don't have this stack resource, have to transition
+  // explicitly.
   __ cmpl(compiler::Address(
               THR, compiler::target::Thread::exit_through_ffi_offset()),
           compiler::Immediate(target::Thread::exit_through_ffi()));
   __ j(NOT_EQUAL, &exit_through_non_ffi, compiler::Assembler::kNearJump);
-  __ TransitionNativeToGenerated(ECX, /*leave_safepoint=*/true);
+  __ TransitionNativeToGenerated(ECX, /*leave_safepoint=*/true,
+                                 /*ignore_unwind_in_progress=*/true);
   __ Bind(&exit_through_non_ffi);
 
   // Set tag.
diff --git a/runtime/vm/compiler/stub_code_compiler_x64.cc b/runtime/vm/compiler/stub_code_compiler_x64.cc
index ae87dca..fb870b5 100644
--- a/runtime/vm/compiler/stub_code_compiler_x64.cc
+++ b/runtime/vm/compiler/stub_code_compiler_x64.cc
@@ -335,7 +335,8 @@
   __ ret();
 }
 
-void StubCodeCompiler::GenerateExitSafepointStub(Assembler* assembler) {
+static void GenerateExitSafepointStubCommon(Assembler* assembler,
+                                            uword runtime_entry_offset) {
   RegisterSet all_registers;
   all_registers.AddAllGeneralRegisters();
   __ PushRegisters(all_registers);
@@ -349,7 +350,7 @@
   __ movq(Address(THR, target::Thread::execution_state_offset()),
           Immediate(target::Thread::vm_execution_state()));
 
-  __ movq(RAX, Address(THR, kExitSafepointRuntimeEntry.OffsetFromThread()));
+  __ movq(RAX, Address(THR, runtime_entry_offset));
   __ CallCFunction(RAX);
   __ LeaveFrame();
 
@@ -357,6 +358,18 @@
   __ ret();
 }
 
+void StubCodeCompiler::GenerateExitSafepointStub(Assembler* assembler) {
+  GenerateExitSafepointStubCommon(
+      assembler, kExitSafepointRuntimeEntry.OffsetFromThread());
+}
+
+void StubCodeCompiler::GenerateExitSafepointIgnoreUnwindInProgressStub(
+    Assembler* assembler) {
+  GenerateExitSafepointStubCommon(
+      assembler,
+      kExitSafepointIgnoreUnwindInProgressRuntimeEntry.OffsetFromThread());
+}
+
 // Calls native code within a safepoint.
 //
 // On entry:
@@ -3140,12 +3153,18 @@
 #error Unimplemented
 #endif
   Label exit_through_non_ffi;
-  // Check if we exited generated from FFI. If so do transition.
+  // Check if we exited generated from FFI. If so do transition - this is needed
+  // because normally runtime calls transition back to generated via destructor
+  // of TransititionGeneratedToVM/Native that is part of runtime boilerplate
+  // code (see DEFINE_RUNTIME_ENTRY_IMPL in runtime_entry.h). Ffi calls don't
+  // have this boilerplate, don't have this stack resource, have to transition
+  // explicitly.
   __ cmpq(compiler::Address(
               THR, compiler::target::Thread::exit_through_ffi_offset()),
           compiler::Immediate(target::Thread::exit_through_ffi()));
   __ j(NOT_EQUAL, &exit_through_non_ffi, compiler::Assembler::kNearJump);
-  __ TransitionNativeToGenerated(/*leave_safepoint=*/true);
+  __ TransitionNativeToGenerated(/*leave_safepoint=*/true,
+                                 /*ignore_unwind_in_progress=*/true);
   __ Bind(&exit_through_non_ffi);
 
   // Set the tag.
diff --git a/runtime/vm/dart.cc b/runtime/vm/dart.cc
index 9f78ed8..1f74527 100644
--- a/runtime/vm/dart.cc
+++ b/runtime/vm/dart.cc
@@ -7,7 +7,6 @@
 
 #include "vm/dart.h"
 
-#include "platform/thread_sanitizer.h"
 #include "vm/app_snapshot.h"
 #include "vm/code_observers.h"
 #include "vm/compiler/runtime_offsets_extracted.h"
@@ -51,13 +50,6 @@
 #include "vm/virtual_memory.h"
 #include "vm/zone.h"
 
-#if defined(USING_THREAD_SANITIZER)
-// TODO(https://github.com/dart-lang/sdk/issues/46699): Remove.
-// TODO(https://bugs.fuchsia.dev/p/fuchsia/issues/detail?id=83298): Remove.
-#include "unicode/uchar.h"
-#include "unicode/uniset.h"
-#endif
-
 namespace dart {
 
 DECLARE_FLAG(bool, print_class_table);
@@ -273,13 +265,6 @@
                      Dart_CodeObserver* observer,
                      Dart_PostTaskCallback post_task,
                      void* post_task_data) {
-#if defined(USING_THREAD_SANITIZER)
-  // Trigger lazy initialization in ICU to avoid spurious TSAN warning.
-  // TODO(https://github.com/dart-lang/sdk/issues/46699): Remove.
-  // TODO(https://bugs.fuchsia.dev/p/fuchsia/issues/detail?id=83298): Remove.
-  u_getPropertyValueEnum(UCHAR_SCRIPT, "foo");
-#endif
-
   CheckOffsets();
 
   if (!Flags::Initialized()) {
@@ -343,6 +328,7 @@
   Isolate::InitVM();
   UserTags::Init();
   PortMap::Init();
+  Service::Init();
   FreeListElement::Init();
   ForwardingCorpse::Init();
   Api::Init();
@@ -802,6 +788,7 @@
   ShutdownIsolate();
   vm_isolate_ = NULL;
   ASSERT(Isolate::IsolateListLength() == 0);
+  Service::Cleanup();
   PortMap::Cleanup();
   UserTags::Cleanup();
   IsolateGroup::Cleanup();
diff --git a/runtime/vm/exceptions.cc b/runtime/vm/exceptions.cc
index fc6e47b..41c46cf 100644
--- a/runtime/vm/exceptions.cc
+++ b/runtime/vm/exceptions.cc
@@ -650,6 +650,9 @@
   ExcpHandler func =
       reinterpret_cast<ExcpHandler>(StubCode::JumpToFrame().EntryPoint());
 
+  if (thread->is_unwind_in_progress()) {
+    thread->SetUnwindErrorInProgress(true);
+  }
   func(program_counter, stack_pointer, frame_pointer, thread);
 
 #endif
diff --git a/runtime/vm/experimental_features.cc b/runtime/vm/experimental_features.cc
index f272686..5200b16 100644
--- a/runtime/vm/experimental_features.cc
+++ b/runtime/vm/experimental_features.cc
@@ -6,7 +6,7 @@
 // Instead modify 'tools/experimental_features.yaml' and run
 // 'dart tools/generate_experimental_flags.dart' to update.
 //
-// Current version: 2.16.0
+// Current version: 2.17.0
 
 #include "vm/experimental_features.h"
 
diff --git a/runtime/vm/experimental_features.h b/runtime/vm/experimental_features.h
index 020ba59..d1a5abb 100644
--- a/runtime/vm/experimental_features.h
+++ b/runtime/vm/experimental_features.h
@@ -6,7 +6,7 @@
 // Instead modify 'tools/experimental_features.yaml' and run
 // 'dart tools/generate_experimental_flags.dart' to update.
 //
-// Current version: 2.16.0
+// Current version: 2.17.0
 
 #ifndef RUNTIME_VM_EXPERIMENTAL_FEATURES_H_
 #define RUNTIME_VM_EXPERIMENTAL_FEATURES_H_
diff --git a/runtime/vm/heap/scavenger.h b/runtime/vm/heap/scavenger.h
index ca75d9a..bc626a5 100644
--- a/runtime/vm/heap/scavenger.h
+++ b/runtime/vm/heap/scavenger.h
@@ -439,7 +439,9 @@
   RelaxedAtomic<bool> failed_to_promote_;
   RelaxedAtomic<bool> abort_;
 
-  bool growth_control_;
+  // When the isolate group is ready it will enable growth control via
+  // InitGrowthControl.
+  bool growth_control_ = false;
 
   // Protects new space during the allocation of new TLABs
   mutable Mutex space_lock_;
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index ab78804..360c4a4 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -68,6 +68,7 @@
 class CodeStatistics;
 class IsolateGroupReloadContext;
 class ObjectGraphCopier;
+class NativeArguments;
 
 #define REUSABLE_FORWARD_DECLARATION(name) class Reusable##name##HandleScope;
 REUSABLE_HANDLE_LIST(REUSABLE_FORWARD_DECLARATION)
@@ -236,6 +237,8 @@
   OBJECT_SERVICE_SUPPORT(object)                                               \
   friend class Object;
 
+extern "C" void DFLRT_ExitSafepoint(NativeArguments __unusable_);
+
 #define HEAP_OBJECT_IMPLEMENTATION(object, super)                              \
   OBJECT_IMPLEMENTATION(object, super);                                        \
   Untagged##object* untag() const {                                            \
@@ -244,7 +247,8 @@
   }                                                                            \
   SNAPSHOT_SUPPORT(object)                                                     \
   friend class StackFrame;                                                     \
-  friend class Thread;
+  friend class Thread;                                                         \
+  friend void DFLRT_ExitSafepoint(NativeArguments __unusable_);
 
 // This macro is used to denote types that do not have a sub-type.
 #define FINAL_HEAP_OBJECT_IMPLEMENTATION_HELPER(object, rettype, super)        \
@@ -270,7 +274,8 @@
   SNAPSHOT_SUPPORT(rettype)                                                    \
   friend class Object;                                                         \
   friend class StackFrame;                                                     \
-  friend class Thread;
+  friend class Thread;                                                         \
+  friend void DFLRT_ExitSafepoint(NativeArguments __unusable_);
 
 #define FINAL_HEAP_OBJECT_IMPLEMENTATION(object, super)                        \
   FINAL_HEAP_OBJECT_IMPLEMENTATION_HELPER(object, object, super)
diff --git a/runtime/vm/object_reload.cc b/runtime/vm/object_reload.cc
index d4ed8d0..9fdbffd 100644
--- a/runtime/vm/object_reload.cc
+++ b/runtime/vm/object_reload.cc
@@ -325,9 +325,13 @@
 
   {
     field = old_enum.LookupStaticField(Symbols::Values());
-    ASSERT(!field.IsNull() && field.is_static() && field.is_const());
-    old_enum_values ^= field.StaticConstFieldValue();
-    ASSERT(!old_enum_values.IsNull());
+    if (!field.IsNull()) {
+      ASSERT(field.is_static() && field.is_const());
+      old_enum_values ^= field.StaticConstFieldValue();
+      ASSERT(!old_enum_values.IsNull());
+    } else {
+      old_enum_values = Array::empty_array().ptr();
+    }
 
     field = old_enum.LookupStaticField(Symbols::_DeletedEnumSentinel());
     ASSERT(!field.IsNull() && field.is_static() && field.is_const());
@@ -357,9 +361,13 @@
   bool enums_deleted = false;
   {
     field = LookupStaticField(Symbols::Values());
-    ASSERT(!field.IsNull() && field.is_static() && field.is_const());
-    enum_values ^= field.StaticConstFieldValue();
-    ASSERT(!enum_values.IsNull());
+    if (!field.IsNull()) {
+      ASSERT(field.is_static() && field.is_const());
+      enum_values ^= field.StaticConstFieldValue();
+      ASSERT(!enum_values.IsNull());
+    } else {
+      enum_values = Array::empty_array().ptr();
+    }
 
     field = LookupStaticField(Symbols::_DeletedEnumSentinel());
     ASSERT(!field.IsNull() && field.is_static() && field.is_const());
diff --git a/runtime/vm/object_store.cc b/runtime/vm/object_store.cc
index 9fc1c99..b7c1cb3 100644
--- a/runtime/vm/object_store.cc
+++ b/runtime/vm/object_store.cc
@@ -87,6 +87,10 @@
   set_preallocated_unhandled_exception(UnhandledException::Handle(
       zone, UnhandledException::New(Instance::Cast(out_of_memory),
                                     preallocated_stack_trace)));
+  const UnwindError& preallocated_unwind_error =
+      UnwindError::Handle(zone, UnwindError::New(String::Handle(
+                                    zone, String::New("isolate is exiting"))));
+  set_preallocated_unwind_error(preallocated_unwind_error);
 
   return Error::null();
 }
diff --git a/runtime/vm/object_store.h b/runtime/vm/object_store.h
index 03125b2..19689f0 100644
--- a/runtime/vm/object_store.h
+++ b/runtime/vm/object_store.h
@@ -308,6 +308,7 @@
 #define ISOLATE_OBJECT_STORE_FIELD_LIST(R_, RW)                                \
   RW(UnhandledException, preallocated_unhandled_exception)                     \
   RW(StackTrace, preallocated_stack_trace)                                     \
+  RW(UnwindError, preallocated_unwind_error)                                   \
   RW(Array, dart_args_1)                                                       \
   RW(Array, dart_args_2)                                                       \
   R_(GrowableObjectArray, resume_capabilities)                                 \
diff --git a/runtime/vm/runtime_entry.cc b/runtime/vm/runtime_entry.cc
index c693c02..b5b7854 100644
--- a/runtime/vm/runtime_entry.cc
+++ b/runtime/vm/runtime_entry.cc
@@ -3608,11 +3608,47 @@
   ASSERT(thread->top_exit_frame_info() != 0);
 
   ASSERT(thread->execution_state() == Thread::kThreadInVM);
+  if (thread->is_unwind_in_progress()) {
+    // Clean up safepoint unwind error marker to prevent safepoint tripping.
+    // The safepoint marker will get restored just before jumping back
+    // to generated code.
+    thread->SetUnwindErrorInProgress(false);
+    NoSafepointScope no_safepoint;
+    Error unwind_error;
+    unwind_error ^=
+        thread->isolate()->isolate_object_store()->preallocated_unwind_error();
+    Exceptions::PropagateError(unwind_error);
+  }
   thread->ExitSafepoint();
+
   TRACE_RUNTIME_CALL("%s", "ExitSafepoint done");
 }
 DEFINE_RAW_LEAF_RUNTIME_ENTRY(ExitSafepoint, 0, false, &DFLRT_ExitSafepoint);
 
+// This is expected to be invoked when jumping to destination frame,
+// during exception handling.
+extern "C" void DFLRT_ExitSafepointIgnoreUnwindInProgress(
+    NativeArguments __unusable_) {
+  CHECK_STACK_ALIGNMENT;
+  TRACE_RUNTIME_CALL("%s", "ExitSafepointIgnoreUnwindInProgress");
+  Thread* thread = Thread::Current();
+  ASSERT(thread->top_exit_frame_info() != 0);
+
+  ASSERT(thread->execution_state() == Thread::kThreadInVM);
+
+  // Compared to ExitSafepoint above we are going to ignore
+  // is_unwind_in_progress flag because this is called as part of JumpToFrame
+  // exception handler - we want this transition to complete so that the next
+  // safepoint check does error propagation.
+  thread->ExitSafepoint();
+
+  TRACE_RUNTIME_CALL("%s", "ExitSafepointIgnoreUnwindInProgress done");
+}
+DEFINE_RAW_LEAF_RUNTIME_ENTRY(ExitSafepointIgnoreUnwindInProgress,
+                              0,
+                              false,
+                              &DFLRT_ExitSafepointIgnoreUnwindInProgress);
+
 // Not registered as a runtime entry because we can't use Thread to look it up.
 static Thread* GetThreadForNativeCallback(uword callback_id,
                                           uword return_address) {
diff --git a/runtime/vm/runtime_entry_list.h b/runtime/vm/runtime_entry_list.h
index 0fa921a..5731d55 100644
--- a/runtime/vm/runtime_entry_list.h
+++ b/runtime/vm/runtime_entry_list.h
@@ -96,6 +96,7 @@
     uword /*SmiPtr*/, uword /*SmiPtr*/, uword /*SmiPtr*/)                      \
   V(void, EnterSafepoint)                                                      \
   V(void, ExitSafepoint)                                                       \
+  V(void, ExitSafepointIgnoreUnwindInProgress)                                 \
   V(ApiLocalScope*, EnterHandleScope, Thread*)                                 \
   V(void, ExitHandleScope, Thread*)                                            \
   V(LocalHandle*, AllocateHandle, ApiLocalScope*)                              \
diff --git a/runtime/vm/service.cc b/runtime/vm/service.cc
index 38e0d75..2f2a075 100644
--- a/runtime/vm/service.cc
+++ b/runtime/vm/service.cc
@@ -72,6 +72,56 @@
             "Print a message when an isolate is paused but there is no "
             "debugger attached.");
 
+DEFINE_FLAG(
+    charp,
+    log_service_response_sizes,
+    nullptr,
+    "Log sizes of service responses and events to a file in CSV format.");
+
+void* Service::service_response_size_log_file_ = nullptr;
+
+void Service::LogResponseSize(const char* method, JSONStream* js) {
+  if (service_response_size_log_file_ == nullptr) {
+    return;
+  }
+  Dart_FileWriteCallback file_write = Dart::file_write_callback();
+  char* entry =
+      OS::SCreate(nullptr, "%s, %" Pd "\n", method, js->buffer()->length());
+  (*file_write)(entry, strlen(entry), service_response_size_log_file_);
+  free(entry);
+}
+
+void Service::Init() {
+  if (FLAG_log_service_response_sizes == nullptr) {
+    return;
+  }
+  Dart_FileOpenCallback file_open = Dart::file_open_callback();
+  Dart_FileWriteCallback file_write = Dart::file_write_callback();
+  Dart_FileCloseCallback file_close = Dart::file_close_callback();
+  if ((file_open == nullptr) || (file_write == nullptr) ||
+      (file_close == nullptr)) {
+    OS::PrintErr("Error: Could not access file callbacks.");
+    UNREACHABLE();
+  }
+  ASSERT(service_response_size_log_file_ == nullptr);
+  service_response_size_log_file_ =
+      (*file_open)(FLAG_log_service_response_sizes, true);
+  if (service_response_size_log_file_ == nullptr) {
+    OS::PrintErr("Warning: Failed to open service response size log file: %s\n",
+                 FLAG_log_service_response_sizes);
+    return;
+  }
+}
+
+void Service::Cleanup() {
+  if (service_response_size_log_file_ == nullptr) {
+    return;
+  }
+  Dart_FileCloseCallback file_close = Dart::file_close_callback();
+  (*file_close)(service_response_size_log_file_);
+  service_response_size_log_file_ = nullptr;
+}
+
 static void PrintInvalidParamError(JSONStream* js, const char* param) {
 #if !defined(PRODUCT)
   js->PrintError(kInvalidParams, "%s: invalid '%s' parameter: %s", js->method(),
@@ -988,6 +1038,7 @@
         return T->StealStickyError();
       }
       method->entry(T, &js);
+      Service::LogResponseSize(c_method_name, &js);
       js.PostReply();
       return T->StealStickyError();
     }
@@ -1239,6 +1290,8 @@
     }
   }
 
+  Service::LogResponseSize(kind, event);
+
   // Message is of the format [<stream id>, <json string>].
   //
   // Build the event message in the C heap to avoid dart heap
diff --git a/runtime/vm/service.h b/runtime/vm/service.h
index 751c1e5..d6324d9 100644
--- a/runtime/vm/service.h
+++ b/runtime/vm/service.h
@@ -89,6 +89,9 @@
 
 class Service : public AllStatic {
  public:
+  static void Init();
+  static void Cleanup();
+
   // Handles a message which is not directed to an isolate.
   static ErrorPtr HandleRootMessage(const Array& message);
 
@@ -159,6 +162,9 @@
                         const Instance& id,
                         const Error& error);
 
+  // Logs the size of the contents of `js` to FLAG_log_service_response_sizes.
+  static void LogResponseSize(const char* method, JSONStream* js);
+
   // Enable/Disable timeline categories.
   // Returns True if the categories were successfully enabled, False otherwise.
   static bool EnableTimelineStreams(char* categories_list);
@@ -250,6 +256,8 @@
   static Dart_GetVMServiceAssetsArchive get_service_assets_callback_;
   static Dart_EmbedderInformationCallback embedder_information_callback_;
 
+  static void* service_response_size_log_file_;
+
   static const uint8_t* dart_library_kernel_;
   static intptr_t dart_library_kernel_len_;
 };
diff --git a/runtime/vm/stub_code_list.h b/runtime/vm/stub_code_list.h
index fa7b06b..778e08c 100644
--- a/runtime/vm/stub_code_list.h
+++ b/runtime/vm/stub_code_list.h
@@ -125,6 +125,7 @@
   V(OneArgOptimizedCheckInlineCacheWithExactnessCheck)                         \
   V(EnterSafepoint)                                                            \
   V(ExitSafepoint)                                                             \
+  V(ExitSafepointIgnoreUnwindInProgress)                                       \
   V(CallNativeThroughSafepoint)                                                \
   V(InitStaticField)                                                           \
   V(InitLateStaticField)                                                       \
diff --git a/runtime/vm/thread.h b/runtime/vm/thread.h
index ed9e9b7..be48283 100644
--- a/runtime/vm/thread.h
+++ b/runtime/vm/thread.h
@@ -151,6 +151,8 @@
     StubCode::LazySpecializeTypeTest().ptr(), nullptr)                         \
   V(CodePtr, enter_safepoint_stub_, StubCode::EnterSafepoint().ptr(), nullptr) \
   V(CodePtr, exit_safepoint_stub_, StubCode::ExitSafepoint().ptr(), nullptr)   \
+  V(CodePtr, exit_safepoint_ignore_unwind_in_progress_stub_,                   \
+    StubCode::ExitSafepointIgnoreUnwindInProgress().ptr(), nullptr)            \
   V(CodePtr, call_native_through_safepoint_stub_,                              \
     StubCode::CallNativeThroughSafepoint().ptr(), nullptr)
 
@@ -565,7 +567,10 @@
 
   bool is_unwind_in_progress() const { return is_unwind_in_progress_; }
 
-  void StartUnwindError() { is_unwind_in_progress_ = true; }
+  void StartUnwindError() {
+    is_unwind_in_progress_ = true;
+    SetUnwindErrorInProgress(true);
+  }
 
 #if defined(DEBUG)
   void EnterCompiler() {
@@ -813,6 +818,9 @@
    * - Bit 4 of the safepoint_state_ field is used to indicate that the thread
    *   is blocked at a (deopt)safepoint and has to be woken up once the
    *   (deopt)safepoint operation is complete.
+   * - Bit 6 of the safepoint_state_ field is used to indicate that the isolate
+   *   running on this thread has triggered unwind error, which requires
+   *   enforced exit on a transition from native back to generated.
    *
    * The safepoint execution state (described above) for a thread is stored in
    * in the execution_state_ field.
@@ -903,6 +911,15 @@
   static uword SetBypassSafepoints(bool value, uword state) {
     return BypassSafepointsField::update(value, state);
   }
+  bool UnwindErrorInProgress() const {
+    return UnwindErrorInProgressField::decode(safepoint_state_);
+  }
+  void SetUnwindErrorInProgress(bool value) {
+    safepoint_state_ =
+        UnwindErrorInProgressField::update(value, safepoint_state_);
+  }
+
+  uword safepoint_state() { return safepoint_state_; }
 
   enum ExecutionState {
     kThreadInVM = 0,
@@ -1210,6 +1227,8 @@
                         1> {};
   class BypassSafepointsField
       : public BitField<uword, bool, BlockedForSafepointField::kNextBit, 1> {};
+  class UnwindErrorInProgressField
+      : public BitField<uword, bool, BypassSafepointsField::kNextBit, 1> {};
 
   static uword AtSafepointBits(SafepointLevel level) {
     switch (level) {
diff --git a/runtime/vm/unit_test.cc b/runtime/vm/unit_test.cc
index a2478ad..5242592 100644
--- a/runtime/vm/unit_test.cc
+++ b/runtime/vm/unit_test.cc
@@ -667,7 +667,7 @@
   return Api::NewHandle(thread, val.ptr());
 }
 
-#if !defined(PRODUCT) && defined(TARGET_ARCH_IA32)
+#if !defined(PRODUCT) && (defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64))
 static bool IsHex(int c) {
   return ('0' <= c && c <= '9') || ('a' <= c && c <= 'f');
 }
@@ -705,9 +705,11 @@
   }
   Disassembler::Disassemble(start, start + assembler_->CodeSize(), disassembly_,
                             DISASSEMBLY_SIZE);
-#if defined(TARGET_ARCH_IA32)
-  // Blank out absolute addressing constants, since they are not stable from run
-  // to run.
+#if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
+  // Blank out absolute addressing constants on ia32, since they are not stable
+  // from run to run.
+  // Blank out thread-relative offsets on x64 since they change when new fields
+  // are added to thread object.
   bool in_hex_constant = false;
   for (char* p = disassembly_; *p != '\0'; p++) {
     if (in_hex_constant) {
@@ -717,14 +719,24 @@
         in_hex_constant = false;
       }
     } else {
+#if defined(TARGET_ARCH_IA32)
       if (*p == '[' && *(p + 1) == '0' && *(p + 2) == 'x' && IsHex(*(p + 3)) &&
           IsHex(*(p + 4))) {
         p += 2;
         in_hex_constant = true;
       }
+#endif  // defined(TARGET_ARCH_IA32)
+#if defined(TARGET_ARCH_X64)
+      if (*p == '[' && *(p + 1) == 't' && *(p + 2) == 'h' && *(p + 3) == 'r' &&
+          *(p + 4) == '+' && *(p + 5) == '0' && *(p + 6) == 'x' &&
+          IsHex(*(p + 7)) && IsHex(*(p + 8))) {
+        p += 6;
+        in_hex_constant = true;
+      }
+#endif  // defined(TARGET_ARCH_X64)
     }
   }
-#endif  // TARGET_ARCH_IA32
+#endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
 #endif  // !PRODUCT
 }
 
diff --git a/sdk/lib/PRESUBMIT.py b/sdk/lib/PRESUBMIT.py
new file mode 100644
index 0000000..21b779b
--- /dev/null
+++ b/sdk/lib/PRESUBMIT.py
@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+# Copyright (c) 2022, 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.
+"""sdk/lib specific presubmit script.
+
+See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
+for more details about the presubmit API built into gcl.
+"""
+
+import imp
+import os.path
+import subprocess
+
+USE_PYTHON3 = True
+
+
+def runSmokeTest(input_api, output_api):
+    hasChangedFiles = False
+    for git_file in input_api.AffectedTextFiles():
+        filename = git_file.AbsoluteLocalPath()
+        if filename.endswith('libraries.yaml') or filename.endswith(
+                'libraries.json'):
+            hasChangedFiles = True
+            break
+
+    if hasChangedFiles:
+        local_root = input_api.change.RepositoryRoot()
+        utils = imp.load_source('utils',
+                                os.path.join(local_root, 'tools', 'utils.py'))
+        dart = os.path.join(utils.CheckedInSdkPath(), 'bin', 'dart')
+        yaml2json = os.path.join(local_root, 'tools', 'yaml2json.dart')
+        libYaml = os.path.join(local_root, 'sdk', 'lib', 'libraries.yaml')
+        libJson = os.path.join(local_root, 'sdk', 'lib', 'libraries.json')
+
+        windows = utils.GuessOS() == 'win32'
+        if windows:
+            dart += '.exe'
+
+        if not os.path.isfile(dart):
+            print('WARNING: dart not found: %s' % dart)
+            return []
+
+        if not os.path.isfile(yaml2json):
+            print('WARNING: yaml2json not found: %s' % yaml2json)
+            return []
+
+        args = [
+            dart, yaml2json, libYaml, libJson, '--check',
+            '--relative=' + local_root + '/'
+        ]
+        process = subprocess.Popen(args,
+                                   stdout=subprocess.PIPE,
+                                   stdin=subprocess.PIPE)
+        outs, _ = process.communicate()
+
+        if process.returncode != 0:
+            return [
+                output_api.PresubmitError('lib/sdk smoketest failure(s)',
+                                          long_text=outs)
+            ]
+
+    return []
+
+
+def CheckChangeOnCommit(input_api, output_api):
+    return runSmokeTest(input_api, output_api)
+
+
+def CheckChangeOnUpload(input_api, output_api):
+    return runSmokeTest(input_api, output_api)
diff --git a/sdk/lib/_internal/js_dev_runtime/patch/core_patch.dart b/sdk/lib/_internal/js_dev_runtime/patch/core_patch.dart
index 6b133cb..95b46d6 100644
--- a/sdk/lib/_internal/js_dev_runtime/patch/core_patch.dart
+++ b/sdk/lib/_internal/js_dev_runtime/patch/core_patch.dart
@@ -166,6 +166,22 @@
 }
 
 @patch
+class WeakReference<T extends Object> {
+  @patch
+  factory WeakReference(T object) {
+    throw UnimplementedError("WeakReference");
+  }
+}
+
+@patch
+class Finalizer<T> {
+  @patch
+  factory Finalizer(void Function(T) object) {
+    throw UnimplementedError("Finalizer");
+  }
+}
+
+@patch
 class int {
   @patch
   static int parse(String source,
diff --git a/sdk/lib/_internal/js_runtime/lib/core_patch.dart b/sdk/lib/_internal/js_runtime/lib/core_patch.dart
index 9579a76..529682d 100644
--- a/sdk/lib/_internal/js_runtime/lib/core_patch.dart
+++ b/sdk/lib/_internal/js_runtime/lib/core_patch.dart
@@ -118,6 +118,22 @@
 }
 
 @patch
+class WeakReference<T extends Object> {
+  @patch
+  factory WeakReference(T object) {
+    throw UnimplementedError("WeakReference");
+  }
+}
+
+@patch
+class Finalizer<T> {
+  @patch
+  factory Finalizer(void Function(T) object) {
+    throw UnimplementedError("Finalizer");
+  }
+}
+
+@patch
 class int {
   @patch
   static int parse(String source,
diff --git a/sdk/lib/_internal/vm/lib/compact_hash.dart b/sdk/lib/_internal/vm/lib/compact_hash.dart
index f9b905b..a39e324 100644
--- a/sdk/lib/_internal/vm/lib/compact_hash.dart
+++ b/sdk/lib/_internal/vm/lib/compact_hash.dart
@@ -532,11 +532,18 @@
   }
 
   void forEach(void f(K key, V value)) {
-    var ki = keys.iterator;
-    var vi = values.iterator;
-    while (ki.moveNext()) {
-      vi.moveNext();
-      f(ki.current, vi.current);
+    final data = _data;
+    final checkSum = _checkSum;
+    final len = _usedData;
+    for (int offset = 0; offset < len; offset += 2) {
+      final current = data[offset];
+      if (_HashBase._isDeleted(data, current)) continue;
+      final key = internal.unsafeCast<K>(current);
+      final value = internal.unsafeCast<V>(data[offset + 1]);
+      f(key, value);
+      if (_isModifiedSince(data, checkSum)) {
+        throw ConcurrentModificationError(this);
+      }
     }
   }
 
diff --git a/sdk/lib/_internal/vm/lib/expando_patch.dart b/sdk/lib/_internal/vm/lib/expando_patch.dart
index f707102..be89c3e 100644
--- a/sdk/lib/_internal/vm/lib/expando_patch.dart
+++ b/sdk/lib/_internal/vm/lib/expando_patch.dart
@@ -166,3 +166,19 @@
   List<_WeakProperty?> _data;
   int _used; // Number of used (active and deleted) slots.
 }
+
+@patch
+class WeakReference<T extends Object> {
+  @patch
+  factory WeakReference(T object) {
+    throw UnimplementedError("WeakReference");
+  }
+}
+
+@patch
+class Finalizer<T> {
+  @patch
+  factory Finalizer(void Function(T) object) {
+    throw UnimplementedError("Finalizer");
+  }
+}
diff --git a/sdk/lib/_internal/vm/lib/isolate_patch.dart b/sdk/lib/_internal/vm/lib/isolate_patch.dart
index 37fb390..6e3aabf 100644
--- a/sdk/lib/_internal/vm/lib/isolate_patch.dart
+++ b/sdk/lib/_internal/vm/lib/isolate_patch.dart
@@ -312,7 +312,7 @@
   static Isolate get current => _currentIsolate;
 
   @patch
-  String get debugName => _getDebugName(controlPort);
+  String? get debugName => _getDebugName(controlPort);
 
   @patch
   static Future<Uri?> get packageRoot {
diff --git a/sdk/lib/core/core.dart b/sdk/lib/core/core.dart
index 3799c08..324a84b 100644
--- a/sdk/lib/core/core.dart
+++ b/sdk/lib/core/core.dart
@@ -181,7 +181,6 @@
 part "enum.dart";
 part "errors.dart";
 part "exceptions.dart";
-part "expando.dart";
 part "function.dart";
 part "identical.dart";
 part "int.dart";
@@ -206,3 +205,4 @@
 part "symbol.dart";
 part "type.dart";
 part "uri.dart";
+part "weak.dart";
diff --git a/sdk/lib/core/core_sources.gni b/sdk/lib/core/core_sources.gni
index 66362e9..12f70fb 100644
--- a/sdk/lib/core/core_sources.gni
+++ b/sdk/lib/core/core_sources.gni
@@ -16,7 +16,6 @@
   "enum.dart",
   "errors.dart",
   "exceptions.dart",
-  "expando.dart",
   "function.dart",
   "identical.dart",
   "int.dart",
@@ -41,4 +40,5 @@
   "symbol.dart",
   "type.dart",
   "uri.dart",
+  "weak.dart",
 ]
diff --git a/sdk/lib/core/expando.dart b/sdk/lib/core/expando.dart
deleted file mode 100644
index bcdee49..0000000
--- a/sdk/lib/core/expando.dart
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (c) 2012, 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.
-
-part of dart.core;
-
-/// An [Expando] allows adding new properties to objects.
-///
-/// Does not work on numbers, strings, booleans, `null`, `dart:ffi` pointers,
-/// `dart:ffi` structs, or `dart:ffi` unions.
-///
-/// An `Expando` does not hold on to the added property value after an object
-/// becomes inaccessible.
-///
-/// Since you can always create a new number that is identical to an existing
-/// number, it means that an expando property on a number could never be
-/// released. To avoid this, expando properties cannot be added to numbers.
-/// The same argument applies to strings, booleans and `null`, which also have
-/// literals that evaluate to identical values when they occur more than once.
-///
-/// There is no restriction on other classes, even for compile time constant
-/// objects. Be careful if adding expando properties to compile time constants,
-/// since they will stay alive forever.
-class Expando<T extends Object> {
-  /// The name of the this [Expando] as passed to the constructor. If
-  /// no name was passed to the constructor, the name is `null`.
-  final String? name;
-
-  /// Creates a new [Expando]. The optional name is only used for
-  /// debugging purposes and creating two different [Expando]s with the
-  /// same name yields two [Expando]s that work on different properties
-  /// of the objects they are used on.
-  external Expando([String? name]);
-
-  /// Expando toString method override.
-  String toString() => "Expando:$name";
-
-  /// Gets the value of this [Expando]'s property on the given
-  /// object. If the object hasn't been expanded, the method returns
-  /// `null`.
-  ///
-  /// The object must not be a number, a string, a boolean, `null`, a
-  /// `dart:ffi` pointer, a `dart:ffi` struct, or a `dart:ffi` union.
-  external T? operator [](Object object);
-
-  /// Sets the value of this [Expando]'s property on the given
-  /// object. Properties can effectively be removed again by setting
-  /// their value to `null`.
-  ///
-  /// The object must not be a number, a string, a boolean, `null`, a
-  /// `dart:ffi` pointer, a `dart:ffi` struct, or a `dart:ffi` union.
-  external void operator []=(Object object, T? value);
-}
diff --git a/sdk/lib/core/pattern.dart b/sdk/lib/core/pattern.dart
index 7facb38..dbf7a23 100644
--- a/sdk/lib/core/pattern.dart
+++ b/sdk/lib/core/pattern.dart
@@ -20,6 +20,20 @@
   /// and then from the end of the previous match (but always
   /// at least one position later than the *start* of the previous
   /// match, in case the pattern matches an empty substring).
+  /// ```dart
+  /// RegExp exp = RegExp(r'(\w+)');
+  /// var str = 'Dash is a bird';
+  /// Iterable<Match> matches = exp.allMatches(str, 8);
+  /// for (final Match m in matches) {
+  ///   String match = m[0]!;
+  ///   print(match);
+  /// }
+  /// ```
+  /// The output of the example is:
+  /// ```
+  /// a
+  /// bird
+  /// ```
   Iterable<Match> allMatches(String string, [int start = 0]);
 
   /// Matches this pattern against the start of `string`.
@@ -29,6 +43,15 @@
   /// at that point.
   ///
   /// The [start] must be non-negative and no greater than `string.length`.
+  /// ```dart
+  /// final string = 'Dash is a bird';
+  ///
+  /// var regExp = RegExp(r'bird');
+  /// var match = regExp.matchAsPrefix(string, 10); // Match found.
+  ///
+  /// regExp = RegExp(r'bird');
+  /// match = regExp.matchAsPrefix(string); // null
+  /// ```
   Match? matchAsPrefix(String string, [int start = 0]);
 }
 
diff --git a/sdk/lib/core/weak.dart b/sdk/lib/core/weak.dart
new file mode 100644
index 0000000..17f5d31
--- /dev/null
+++ b/sdk/lib/core/weak.dart
@@ -0,0 +1,246 @@
+// Copyright (c) 2012, 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.
+
+part of dart.core;
+
+/// An [Expando] allows adding new properties to objects.
+///
+/// Does not work on numbers, strings, booleans, `null`, `dart:ffi` pointers,
+/// `dart:ffi` structs, or `dart:ffi` unions.
+///
+/// An `Expando` does not hold on to the added property value after an object
+/// becomes inaccessible.
+///
+/// Since you can always create a new number that is identical to an existing
+/// number, it means that an expando property on a number could never be
+/// released. To avoid this, expando properties cannot be added to numbers.
+/// The same argument applies to strings, booleans and `null`, which also have
+/// literals that evaluate to identical values when they occur more than once.
+///
+/// There is no restriction on other classes, even for compile time constant
+/// objects. Be careful if adding expando properties to compile time constants,
+/// since they will stay alive forever.
+class Expando<T extends Object> {
+  /// The name of the this [Expando] as passed to the constructor.
+  ///
+  /// If no name was passed to the constructor, the value is the `null` value.
+  final String? name;
+
+  /// Creates a new [Expando]. The optional name is only used for
+  /// debugging purposes and creating two different [Expando]s with the
+  /// same name yields two [Expando]s that work on different properties
+  /// of the objects they are used on.
+  external Expando([String? name]);
+
+  /// Expando toString method override.
+  String toString() => "Expando:$name";
+
+  /// Gets the value of this [Expando]'s property on the given object.
+  ///
+  /// If the object hasn't been expanded, the result is the `null` value.
+  ///
+  /// The object must not be a number, a string, a boolean, `null`, a
+  /// `dart:ffi` pointer, a `dart:ffi` struct, or a `dart:ffi` union.
+  external T? operator [](Object object);
+
+  /// Sets this [Expando]'s property value on the given object to [value].
+  ///
+  /// Properties can effectively be removed again
+  /// by setting their value to `null`.
+  ///
+  /// The object must not be a number, a string, a boolean, `null`, a
+  /// `dart:ffi` pointer, a `dart:ffi` struct, or a `dart:ffi` union.
+  external void operator []=(Object object, T? value);
+}
+
+/// A weak reference to a Dart object.
+///
+/// A _weak_ reference to the [target] object which may be cleared
+/// (set to reference `null` instead) at any time
+/// when there is no other ways for the program to access the target object.
+///
+/// _Being the target of a weak reference does not keep an object
+/// from being garbage collected._
+///
+/// There are no guarantees that a weak reference will ever be cleared
+/// even if all references to its target are weak references.
+///
+/// Not all objects are supported as targets for weak references.
+/// The [WeakReference] constructor will reject any object that is not
+/// supported as an [Expando] key.
+@Since("2.17")
+abstract class WeakReference<T extends Object> {
+  /// Creates a [WeakReference] pointing to the given [target].
+  ///
+  /// The [target] must be an object supported as an [Expando] key,
+  /// which means [target] cannot be a number, a string, a boolean,
+  /// the `null` value, or certain other types of special objects.
+  external factory WeakReference(T target);
+
+  /// The current object weakly referenced by [this], if any.
+  ///
+  /// The value is either the object supplied in the constructor,
+  /// or `null` if the weak reference has been cleared.
+  T? get target;
+}
+
+/// A finalizer which can be attached to Dart objects.
+///
+/// A finalizer can create attachments between
+/// the finalizer and any number of Dart values,
+/// by calling [attach] with the value, along with a
+/// _finalization token_ and an optional _attach key_,
+/// which are part of the attachment.
+///
+/// When a Dart value becomes inaccessible to the program,
+/// any finalizer that currently has an attachment to
+/// the value *may* have its callback function called
+/// with the attachment's finalization token.
+///
+/// Example:
+/// ```dart template:none
+/// // Keep the finalizer itself reachable, otherwise might not do anything.
+/// final Finalizer<DBConnection> _finalizer = Finalizer((connection) {
+///   connection.close();
+/// });
+///
+/// /// Access the database.
+/// Database connect() {
+///   // Wraps the connection in a nicer user-facing API,
+///   // *and* closes connection if the user forgets to.
+///   var connection = _connectToDatabase();
+///   var wrapper = Database._fromConnection(connection, _finalizer);
+///   // Get finalizer callback when `wrapper` is no longer reachable.
+///   _finalizer.attach(wrapper, connection, detach: wrapper);
+///   return wrapper;
+/// }
+///
+/// class Database {
+///   final DBConnection _connection;
+///   final Finalizer<Connection> _finalizer;
+///   Database._fromConnection(this._connection, this._finalizer);
+///
+///   // Some useful methods.
+///
+///   void close() {
+///     // User requested close.
+///     _connection.close();
+///     // Detach from finalizer, no longer needed.
+///     _finalizer.detach(this);
+///   }
+/// }
+/// ```
+/// This example has an example of an external resource that needs clean-up.
+/// The finalizer is used to clean up an external connection when the
+/// user of the API no longer has access to that connection.
+/// The example uses the same object as attached object and detach key,
+/// which is a useful approach when each attached object can be detached
+/// individually. Being a detachment key doesn't keep an object alive.
+///
+/// No promises are made that the callback will ever be called.
+/// The only thing that is guaranteed is that if a finalizer's callback
+/// is called with a specific finalization token as argument,
+/// then at least one value with an attachment to to the finalizer
+/// that has that finalization token,
+/// is no longer accessible to the program.
+///
+/// If the finalzier *itself* becomes unreachable,
+/// it's allowed to be garbage collected
+/// and then it won't trigger any further callbacks.
+/// Always make sure to keep the finalizer itself reachable while it's needed.
+///
+/// If multiple finalizers are attached to a single object,
+/// or the same finalizer is attached multiple times to an object,
+/// and that object becomes inaccessible to the program,
+/// then any number (including zero) of those attachments may trigger
+/// their associated finalizer's callback.
+/// It will not necessarily be all or none of them.
+///
+/// Finalization callbacks will happen as *events*.
+/// They will not happen during execution of other code,
+/// and not as a microtask,
+/// but as high-level events similar to timer events.
+///
+/// Finalization callbacks must not throw.
+@Since("2.17")
+abstract class Finalizer<T> {
+  /// Creates a finalizer with the given finalization callback.
+  ///
+  /// The [callback] is bound to the current zone
+  /// when the [Finalizer] is created, and will run in that zone when called.
+  external factory Finalizer(void Function(T) callback);
+
+  /// Attaches this finalizer to [value].
+  ///
+  /// When [value] is longer accessible to the program,
+  /// while still having an attachement to this finalizer,
+  /// the callback of this finalizer *may* be called
+  /// with [finalizationToken] as argument.
+  /// The callback may be called at most once per active attachment,
+  /// ones which have not been detached by calling [Finalizer.detach].
+  ///
+  /// If a non-`null` [detach] value is provided, that object can be
+  /// passed to [Finalizer.detach] to remove the attachment again.
+  ///
+  /// The [value] and [detach] arguments do not count towards those
+  /// objects being accessible to the program.
+  /// Both must be objects supported as an [Expando] key.
+  /// They may be the *same* object.
+  ///
+  /// Example:
+  /// ```dart template:top
+  /// /// Access the data base.
+  /// Database connect() {
+  ///   // Wraps the connection in a nice user API,
+  ///   // *and* closes connection if the user forgets to.
+  ///   var connection = _connectToDatabase();
+  ///   var wrapper = Database._fromConnection(connection, _finalizer);
+  ///   // Get finalizer callback when `wrapper` is no longer reachable.
+  ///   _finalizer.attach(wrapper, connection, detach: wrapper);
+  ///   return wrapper;
+  /// }
+  /// ````
+  ///
+  /// Multiple objects may be attached using the same finalization token,
+  /// and the finalizer can be attached multiple times to the same object
+  /// with different, or the same, finalization token.
+  void attach(Object value, T finalizationToken, {Object? detach});
+
+  /// Detaches the finalizer from values attached with [detachToken].
+  ///
+  /// Each attachment between this finalizer and a value,
+  /// which was created by calling [attach] with the [detachToken] object as
+  /// `detach` argument, is removed.
+  ///
+  /// If the finalizer was attached multiple times to the same value
+  /// with different detachment keys,
+  /// only those attachments which used [detachToken] are removed.
+  ///
+  /// After detaching, an attachment won't cause any callbacks to happen
+  /// if the object become inaccessible.
+  ///
+  /// Example:
+  /// ```dart template:none
+  /// final Finalizer<DBConnection> _finalizer = Finalizer((connection) {
+  ///   connection.close();
+  /// });
+  ///
+  /// class Database {
+  ///   final DBConnection _connection;
+  ///   final Finalizer<Connection> _finalizer;
+  ///   Database._fromConnection(this._connection, this._finalizer);
+  ///
+  ///   // Some useful methods.
+  ///
+  ///   void close() {
+  ///     // User requested close.
+  ///     _connection.close();
+  ///     // Detach from finalizer, no longer needed.
+  ///     // Was attached using this object as `detach` token.
+  ///     _finalizer.detach(this);
+  ///   }
+  /// }
+  /// ```
+  void detach(Object detachToken);
+}
diff --git a/tools/VERSION b/tools/VERSION
index 65a1042..d4dc248 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -25,7 +25,7 @@
 #
 CHANNEL dev
 MAJOR 2
-MINOR 16
+MINOR 17
 PATCH 0
-PRERELEASE 160
+PRERELEASE 0
 PRERELEASE_PATCH 0
\ No newline at end of file
diff --git a/tools/bots/flutter/analyze_flutter_flutter.sh b/tools/bots/flutter/analyze_flutter_flutter.sh
index fbfb264..6fa0425 100755
--- a/tools/bots/flutter/analyze_flutter_flutter.sh
+++ b/tools/bots/flutter/analyze_flutter_flutter.sh
@@ -11,10 +11,6 @@
 dart=$checkout/out/ReleaseX64/dart-sdk/bin/dart
 sdk=$checkout/out/ReleaseX64/dart-sdk
 tmpdir=$(mktemp -d)
-cleanup() {
-  rm -rf "$tmpdir"
-}
-trap cleanup EXIT HUP INT QUIT TERM PIPE
 cd "$tmpdir"
 
 git clone --single-branch -vv \
@@ -37,6 +33,3 @@
 
 # Test flutter's use of data-driven fixes.
 $dart fix packages/flutter/test_fixes --compare-to-golden
-
-# Analyze the sample code in dartdoc snippets.
-PUB_CACHE=$checkout/.pub_cache $dart dev/bots/analyze_sample_code.dart
diff --git a/tools/bots/test_matrix.json b/tools/bots/test_matrix.json
index ed2057e..1312a27 100644
--- a/tools/bots/test_matrix.json
+++ b/tools/bots/test_matrix.json
@@ -3443,6 +3443,15 @@
           ]
         },
         {
+          "name": "analyze pkg/dds_service_extensions",
+          "script": "out/ReleaseX64/dart-sdk/bin/dart",
+          "arguments": [
+            "analyze",
+            "--fatal-infos",
+            "pkg/dds_service_extensions"
+          ]
+        },
+        {
           "name": "analyze runtime/observatory",
           "script": "out/ReleaseX64/dart-sdk/bin/dart",
           "arguments": [
diff --git a/tools/bots/try_benchmarks.sh b/tools/bots/try_benchmarks.sh
index 2fb96f0..3d7f966 100755
--- a/tools/bots/try_benchmarks.sh
+++ b/tools/bots/try_benchmarks.sh
@@ -296,7 +296,7 @@
       out/ReleaseX64/kernel-service.dart.snapshot \
       out/ReleaseX64/run_vm_tests \
       third_party/d8/linux/x64 \
-      third_party/firefox_jsshell/linux/ \
+      third_party/firefox_jsshell/ \
       out/ReleaseX64/dart_precompiled_runtime \
       out/ReleaseX64/gen/utils/dartdevc/kernel/ \
       out/ReleaseX64/ddc_outline.dill \
@@ -333,9 +333,9 @@
     out/ReleaseX64/dart-sdk/bin/dart2js --sound-null-safety --packages=.packages --out=out.js -m hello.dart
     third_party/d8/linux/x64/d8 --stack_size=1024 sdk/lib/_internal/js_runtime/lib/preambles/d8.js out.js
     out/ReleaseX64/dart-sdk/bin/dart2js --packages=.packages --out=out.js -m hello.dart
-    LD_LIBRARY_PATH=third_party/firefox_jsshell/linux/jsshell/ third_party/firefox_jsshell/linux/jsshell/js -f sdk/lib/_internal/js_runtime/lib/preambles/jsshell.js -f out.js
+    LD_LIBRARY_PATH=third_party/firefox_jsshell/ third_party/firefox_jsshell/js -f sdk/lib/_internal/js_runtime/lib/preambles/jsshell.js -f out.js
     out/ReleaseX64/dart-sdk/bin/dart2js --sound-null-safety --packages=.packages --out=out.js -m hello.dart
-    LD_LIBRARY_PATH=third_party/firefox_jsshell/linux/jsshell/ third_party/firefox_jsshell/linux/jsshell/js -f sdk/lib/_internal/js_runtime/lib/preambles/jsshell.js -f out.js
+    LD_LIBRARY_PATH=third_party/firefox_jsshell/ third_party/firefox_jsshell/js -f sdk/lib/_internal/js_runtime/lib/preambles/jsshell.js -f out.js
     out/ReleaseX64/dart-sdk/bin/dart2js --benchmarking-production --packages=.packages --out=out.js -m hello.dart
     third_party/d8/linux/x64/d8 --stack_size=1024 sdk/lib/_internal/js_runtime/lib/preambles/d8.js out.js
     out/ReleaseX64/dart-sdk/bin/dart2js --sound-null-safety --benchmarking-production --packages=.packages --out=out.js -m hello.dart
diff --git a/tools/experimental_features.yaml b/tools/experimental_features.yaml
index 3ca32be..d4c4bb8 100644
--- a/tools/experimental_features.yaml
+++ b/tools/experimental_features.yaml
@@ -103,7 +103,7 @@
 # default 'language' "category" with code generated for both CFE and Analyzer,
 # while other categories can be tailored more specifically.
 
-current-version: '2.16.0'
+current-version: '2.17.0'
 
 features:
   variance:
diff --git a/tools/yaml2json.dart b/tools/yaml2json.dart
index abf313d..50eba45 100644
--- a/tools/yaml2json.dart
+++ b/tools/yaml2json.dart
@@ -10,12 +10,19 @@
 
 import 'package:yaml/yaml.dart' show loadYaml;
 
-main(List<String> arguments) {
+main(List<String> rawArguments) {
   var port = new RawReceivePort();
   bool check = false;
-  if (arguments.contains('--check')) {
-    arguments = arguments.toList()..remove('--check');
-    check = true;
+  String? relative;
+  List<String> arguments = [];
+  for (String argument in rawArguments) {
+    if (argument == '--check') {
+      check = true;
+    } else if (argument.startsWith('--relative=')) {
+      relative = argument.substring('--relative='.length);
+    } else {
+      arguments.add(argument);
+    }
   }
   if (arguments.length != 2) {
     stderr.writeln("Usage: yaml2json.dart input.yaml output.json [--check]");
@@ -23,11 +30,22 @@
   }
   Uri input = Uri.base.resolve(arguments[0]);
   Uri output = Uri.base.resolve(arguments[1]);
+  String inputString = arguments[0];
+  String outputString = arguments[1];
+  if (relative != null) {
+    String relativeTo = Uri.base.resolve(relative).toString();
+    if (input.toString().startsWith(relativeTo)) {
+      inputString = input.toString().substring(relativeTo.length);
+    }
+    if (output.toString().startsWith(relativeTo)) {
+      outputString = output.toString().substring(relativeTo.length);
+    }
+  }
   Map yaml = loadYaml(new File.fromUri(input).readAsStringSync());
   Map<String, dynamic> result = new Map<String, dynamic>();
   result["comment:0"] = "NOTE: THIS FILE IS GENERATED. DO NOT EDIT.";
   result["comment:1"] =
-      "Instead modify '${arguments[0]}' and follow the instructions therein.";
+      "Instead modify '$inputString' and follow the instructions therein.";
   for (String key in yaml.keys) {
     result[key] = yaml[key];
   }
@@ -41,9 +59,9 @@
     }
     if (needsUpdate) {
       stderr.write('''
-The file ${arguments[1]} is not up to date. Regenerate using
+The file $outputString is not up to date. Regenerate using
 
-  dart tools/yaml2json.dart ${arguments[0]} ${arguments[1]}
+  dart tools/yaml2json.dart $inputString $outputString
 ''');
       exit(1);
     }