diff --git a/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart b/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart
index fe7cfc1..6c06628 100644
--- a/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart
@@ -232,11 +232,6 @@
             '{${_info.keys.map((k) => '$k (${k.hashCode})').join(',')}}'));
   }
 
-  /// Indicates whether information is stored for the given [node].
-  bool _hasInfoForNode(Node node) {
-    return _info[node] != null;
-  }
-
   void _printOn(StringBuffer sb) {
     sb.write('_info=$_info,');
     sb.write('_stack=$_stack,');
@@ -894,11 +889,7 @@
 
   /// Call this method just after visiting a "try/finally" statement.
   /// See [tryFinallyStatement_bodyBegin] for details.
-  ///
-  /// [finallyBlock] should be the same node that was passed to
-  /// [AssignedVariables.endNode] for the "finally" part of the try/finally
-  /// statement.
-  void tryFinallyStatement_end(Node finallyBlock);
+  void tryFinallyStatement_end();
 
   /// Call this method just before visiting the finally block of a "try/finally"
   /// statement.  See [tryFinallyStatement_bodyBegin] for details.
@@ -1439,9 +1430,9 @@
   }
 
   @override
-  void tryFinallyStatement_end(Node finallyBlock) {
-    return _wrap('tryFinallyStatement_end($finallyBlock)',
-        () => _wrapped.tryFinallyStatement_end(finallyBlock));
+  void tryFinallyStatement_end() {
+    return _wrap(
+        'tryFinallyStatement_end()', () => _wrapped.tryFinallyStatement_end());
   }
 
   @override
@@ -4095,10 +4086,7 @@
   }
 
   @override
-  void tryFinallyStatement_end(Node finallyBlock) {
-    // We used to need info for `finally` blocks but we don't anymore.
-    assert(!_assignedVariables._hasInfoForNode(finallyBlock),
-        'No assigned variables info should have been stored for $finallyBlock');
+  void tryFinallyStatement_end() {
     _TryFinallyContext<Variable, Type> context =
         _stack.removeLast() as _TryFinallyContext<Variable, Type>;
     _current = context._afterBodyAndCatches!
@@ -4741,7 +4729,7 @@
   void tryFinallyStatement_bodyBegin() {}
 
   @override
-  void tryFinallyStatement_end(Node finallyBlock) {}
+  void tryFinallyStatement_end() {}
 
   @override
   void tryFinallyStatement_finallyBegin(Node body) {}
diff --git a/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_mini_ast.dart b/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_mini_ast.dart
index 024a4c6..afd3020 100644
--- a/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_mini_ast.dart
+++ b/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_mini_ast.dart
@@ -1640,7 +1640,6 @@
   final List<Statement> body;
   final List<Statement> finally_;
   final Node _bodyNode = Node._();
-  final Node _finallyNode = Node._();
 
   _TryFinally(this.body, this.finally_) : super._();
 
@@ -1662,7 +1661,7 @@
     body._visit(h, flow);
     flow.tryFinallyStatement_finallyBegin(_bodyNode);
     finally_._visit(h, flow);
-    flow.tryFinallyStatement_end(_finallyNode);
+    flow.tryFinallyStatement_end();
   }
 }
 
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index b061fe0..e7dd7cf 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -2055,7 +2055,7 @@
       flow.tryFinallyStatement_finallyBegin(
           catchClauses.isNotEmpty ? node : body);
       finallyBlock.accept(this);
-      flow.tryFinallyStatement_end(finallyBlock);
+      flow.tryFinallyStatement_end();
     }
   }
 
diff --git a/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart b/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
index 3b061ee..05af526 100644
--- a/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
@@ -6325,7 +6325,7 @@
       inferrer.flowAnalysis.tryFinallyStatement_finallyBegin(
           node.catchBlocks.isNotEmpty ? node : tryBodyWithAssignedInfo);
       finalizerResult = inferrer.inferStatement(node.finallyBlock);
-      inferrer.flowAnalysis.tryFinallyStatement_end(node.finallyBlock);
+      inferrer.flowAnalysis.tryFinallyStatement_end();
     }
     Statement result =
         tryBlockResult.hasChanged ? tryBlockResult.statement : node.tryBlock;
diff --git a/pkg/nnbd_migration/lib/src/edge_builder.dart b/pkg/nnbd_migration/lib/src/edge_builder.dart
index 850669e..5b97ce5 100644
--- a/pkg/nnbd_migration/lib/src/edge_builder.dart
+++ b/pkg/nnbd_migration/lib/src/edge_builder.dart
@@ -1776,7 +1776,7 @@
       _flowAnalysis.tryFinallyStatement_finallyBegin(
           catchClauses.isNotEmpty ? node : body);
       _dispatch(finallyBlock);
-      _flowAnalysis.tryFinallyStatement_end(finallyBlock);
+      _flowAnalysis.tryFinallyStatement_end();
     }
     return null;
   }
diff --git a/runtime/tests/vm/dart/base_il_serialization_test.dart b/runtime/tests/vm/dart/base_il_serialization_test.dart
deleted file mode 100644
index 569b661..0000000
--- a/runtime/tests/vm/dart/base_il_serialization_test.dart
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright (c) 2019, 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.
-
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --populate_llvm_constant_pool
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --no_serialize_flow_graph_types
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --verbose_flow_graph_serialization
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --no_serialize_flow_graph_types --verbose_flow_graph_serialization
-
-// Just use the existing hello world test.
-import 'hello_world_test.dart' as test;
-
-main(args) {
-  test.main();
-}
diff --git a/runtime/tests/vm/dart/regress_38661_test.dart b/runtime/tests/vm/dart/regress_38661_test.dart
deleted file mode 100644
index 2e1ba13..0000000
--- a/runtime/tests/vm/dart/regress_38661_test.dart
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2019, 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.
-
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --populate_llvm_constant_pool
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --no_serialize_flow_graph_types
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --verbose_flow_graph_serialization
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --no_serialize_flow_graph_types --verbose_flow_graph_serialization
-
-class A {
-  const A();
-}
-
-class B {
-  Object a = const A();
-}
-
-foo(int i) {
-  if (i == 3) {
-    new B();
-  }
-}
-
-main(args) {
-  foo(4);
-}
diff --git a/runtime/tests/vm/dart_2/base_il_serialization_test.dart b/runtime/tests/vm/dart_2/base_il_serialization_test.dart
deleted file mode 100644
index 569b661..0000000
--- a/runtime/tests/vm/dart_2/base_il_serialization_test.dart
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright (c) 2019, 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.
-
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --populate_llvm_constant_pool
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --no_serialize_flow_graph_types
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --verbose_flow_graph_serialization
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --no_serialize_flow_graph_types --verbose_flow_graph_serialization
-
-// Just use the existing hello world test.
-import 'hello_world_test.dart' as test;
-
-main(args) {
-  test.main();
-}
diff --git a/runtime/tests/vm/dart_2/regress_38661_test.dart b/runtime/tests/vm/dart_2/regress_38661_test.dart
deleted file mode 100644
index 2e1ba13..0000000
--- a/runtime/tests/vm/dart_2/regress_38661_test.dart
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2019, 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.
-
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --populate_llvm_constant_pool
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --no_serialize_flow_graph_types
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --verbose_flow_graph_serialization
-// VMOptions=--serialize_flow_graphs_to=il_tmp.txt --no_serialize_flow_graph_types --verbose_flow_graph_serialization
-
-class A {
-  const A();
-}
-
-class B {
-  Object a = const A();
-}
-
-foo(int i) {
-  if (i == 3) {
-    new B();
-  }
-}
-
-main(args) {
-  foo(4);
-}
diff --git a/runtime/vm/compiler/aot/precompiler.cc b/runtime/vm/compiler/aot/precompiler.cc
index 460c9e0..abb8ad0 100644
--- a/runtime/vm/compiler/aot/precompiler.cc
+++ b/runtime/vm/compiler/aot/precompiler.cc
@@ -18,7 +18,6 @@
 #include "vm/compiler/backend/flow_graph.h"
 #include "vm/compiler/backend/flow_graph_compiler.h"
 #include "vm/compiler/backend/il_printer.h"
-#include "vm/compiler/backend/il_serializer.h"
 #include "vm/compiler/backend/inliner.h"
 #include "vm/compiler/backend/linearscan.h"
 #include "vm/compiler/backend/range_analysis.h"
@@ -87,17 +86,6 @@
 DECLARE_FLAG(int, inlining_constant_arguments_min_size_threshold);
 DECLARE_FLAG(bool, print_instruction_stats);
 
-DEFINE_FLAG(charp,
-            serialize_flow_graphs_to,
-            nullptr,
-            "Serialize flow graphs to the given file");
-
-DEFINE_FLAG(bool,
-            populate_llvm_constant_pool,
-            false,
-            "Add constant pool entries from flow graphs to a special pool "
-            "serialized in AOT snapshots (with --serialize_flow_graphs_to)");
-
 Precompiler* Precompiler::singleton_ = nullptr;
 
 #if defined(DART_PRECOMPILER) && !defined(TARGET_ARCH_IA32)
@@ -234,8 +222,7 @@
       consts_to_retain_(),
       seen_table_selectors_(),
       error_(Error::Handle()),
-      get_runtime_type_is_unique_(false),
-      il_serialization_stream_(nullptr) {
+      get_runtime_type_is_unique_(false) {
   ASSERT(Precompiler::singleton_ == NULL);
   Precompiler::singleton_ = this;
 }
@@ -307,32 +294,6 @@
       ClassFinalizer::ClearAllCode(
           /*including_nonchanging_cids=*/FLAG_use_bare_instructions);
 
-      // After this point, it should be safe to serialize flow graphs produced
-      // during compilation and add constants to the LLVM constant pool.
-      //
-      // Check that both the file open and write callbacks are available, though
-      // we only use the latter during IL processing.
-      if (FLAG_serialize_flow_graphs_to != nullptr &&
-          Dart::file_write_callback() != nullptr) {
-        if (auto file_open = Dart::file_open_callback()) {
-          auto file = file_open(FLAG_serialize_flow_graphs_to, /*write=*/true);
-          set_il_serialization_stream(file);
-        }
-        if (FLAG_populate_llvm_constant_pool) {
-          auto const object_store = IG->object_store();
-          auto& llvm_constants = GrowableObjectArray::Handle(
-              Z, GrowableObjectArray::New(16, Heap::kOld));
-          auto& llvm_functions = GrowableObjectArray::Handle(
-              Z, GrowableObjectArray::New(16, Heap::kOld));
-          auto& llvm_constant_hash_table = Array::Handle(
-              Z, HashTables::New<FlowGraphSerializer::LLVMPoolMap>(16,
-                                                                   Heap::kOld));
-          object_store->set_llvm_constant_pool(llvm_constants);
-          object_store->set_llvm_function_pool(llvm_functions);
-          object_store->set_llvm_constant_hash_table(llvm_constant_hash_table);
-        }
-      }
-
       tracer_ = PrecompilerTracer::StartTracingIfRequested(this);
 
       // All stubs have already been generated, all of them share the same pool.
@@ -412,45 +373,6 @@
         }
       }
 
-      if (FLAG_serialize_flow_graphs_to != nullptr &&
-          Dart::file_write_callback() != nullptr) {
-        if (auto file_close = Dart::file_close_callback()) {
-          file_close(il_serialization_stream());
-        }
-        set_il_serialization_stream(nullptr);
-        if (FLAG_populate_llvm_constant_pool) {
-          // We don't want the Array backing for any mappings in the snapshot,
-          // only the pools themselves.
-          IG->object_store()->set_llvm_constant_hash_table(Array::null_array());
-
-          // Keep any functions, classes, etc. referenced from the LLVM pools,
-          // even if they could have been dropped due to not being otherwise
-          // needed at runtime.
-          const auto& constant_pool = GrowableObjectArray::Handle(
-              Z, IG->object_store()->llvm_constant_pool());
-          auto& object = Object::Handle(Z);
-          for (intptr_t i = 0; i < constant_pool.Length(); i++) {
-            object = constant_pool.At(i);
-            if (object.IsNull()) continue;
-            if (object.IsInstance()) {
-              AddConstObject(Instance::Cast(object));
-            } else if (object.IsField()) {
-              AddField(Field::Cast(object));
-            } else if (object.IsFunction()) {
-              AddFunction(Function::Cast(object), RetainReasons::kLLVMPool);
-            }
-          }
-
-          const auto& function_pool = GrowableObjectArray::Handle(
-              Z, IG->object_store()->llvm_function_pool());
-          auto& function = Function::Handle(Z);
-          for (intptr_t i = 0; i < function_pool.Length(); i++) {
-            function ^= function_pool.At(i);
-            AddFunction(function, RetainReasons::kLLVMPool);
-          }
-        }
-      }
-
       if (tracer_ != nullptr) {
         tracer_->Finalize();
         tracer_ = nullptr;
diff --git a/runtime/vm/compiler/aot/precompiler.h b/runtime/vm/compiler/aot/precompiler.h
index 01e2892..48613ee 100644
--- a/runtime/vm/compiler/aot/precompiler.h
+++ b/runtime/vm/compiler/aot/precompiler.h
@@ -250,8 +250,6 @@
     return dispatch_table_generator_->selector_map();
   }
 
-  void* il_serialization_stream() const { return il_serialization_stream_; }
-
   static Precompiler* Instance() { return singleton_; }
 
   void AddField(const Field& field);
@@ -348,10 +346,6 @@
 
   void FinalizeAllClasses();
 
-  void set_il_serialization_stream(void* file) {
-    il_serialization_stream_ = file;
-  }
-
   Thread* thread() const { return thread_; }
   Zone* zone() const { return zone_; }
   Isolate* isolate() const { return isolate_; }
@@ -431,7 +425,6 @@
   compiler::DispatchTableGenerator* dispatch_table_generator_;
 
   bool get_runtime_type_is_unique_;
-  void* il_serialization_stream_;
 
   Phase phase_ = Phase::kPreparation;
   PrecompilerTracer* tracer_ = nullptr;
diff --git a/runtime/vm/compiler/backend/compile_type.h b/runtime/vm/compiler/backend/compile_type.h
index 3a7d6aa..192d541 100644
--- a/runtime/vm/compiler/backend/compile_type.h
+++ b/runtime/vm/compiler/backend/compile_type.h
@@ -18,9 +18,6 @@
 class AbstractType;
 class BaseTextBuffer;
 class Definition;
-class FlowGraphSerializer;
-class SExpression;
-class SExpList;
 
 template <typename T>
 class GrowableArray;
@@ -248,8 +245,6 @@
   bool Specialize(GrowableArray<intptr_t>* class_ids);
 
   void PrintTo(BaseTextBuffer* f) const;
-  SExpression* ToSExpression(FlowGraphSerializer* s) const;
-  void AddExtraInfoToSExpression(SExpList* sexp, FlowGraphSerializer* s) const;
 
   const char* ToCString() const;
 
diff --git a/runtime/vm/compiler/backend/il.h b/runtime/vm/compiler/backend/il.h
index 38006b2..3cf8ffc 100644
--- a/runtime/vm/compiler/backend/il.h
+++ b/runtime/vm/compiler/backend/il.h
@@ -49,7 +49,6 @@
 class Environment;
 class FlowGraph;
 class FlowGraphCompiler;
-class FlowGraphSerializer;
 class FlowGraphVisitor;
 class ForwardInstructionIterator;
 class Instruction;
@@ -59,8 +58,6 @@
 class Range;
 class RangeAnalysis;
 class RangeBoundary;
-class SExpList;
-class SExpression;
 class SuccessorsIterable;
 class TypeUsageInfo;
 class UnboxIntegerInstr;
@@ -150,8 +147,6 @@
   void PrintTo(BaseTextBuffer* f) const;
 #endif  // defined(INCLUDE_IL_PRINTER)
 
-  SExpression* ToSExpression(FlowGraphSerializer* s) const;
-
   const char* ToCString() const;
 
   bool IsSmiValue() { return Type()->ToCid() == kSmiCid; }
@@ -569,17 +564,6 @@
 #define PRINT_OPERANDS_TO_SUPPORT
 #endif  // defined(INCLUDE_IL_PRINTER)
 
-#define TO_S_EXPRESSION_SUPPORT                                                \
-  virtual SExpression* ToSExpression(FlowGraphSerializer* s) const;
-
-#define ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT                                   \
-  virtual void AddOperandsToSExpression(SExpList* sexp,                        \
-                                        FlowGraphSerializer* s) const;
-
-#define ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT                                 \
-  virtual void AddExtraInfoToSExpression(SExpList* sexp,                       \
-                                         FlowGraphSerializer* s) const;
-
 // Together with CidRange, this represents a mapping from a range of class-ids
 // to a method for a given selector (method name).  Also can contain an
 // indication of how frequently a given method has been called at a call site.
@@ -932,11 +916,6 @@
   const char* ToCString() const;
   PRINT_TO_SUPPORT
   PRINT_OPERANDS_TO_SUPPORT
-  virtual SExpression* ToSExpression(FlowGraphSerializer* s) const;
-  virtual void AddOperandsToSExpression(SExpList* sexp,
-                                        FlowGraphSerializer* s) const;
-  virtual void AddExtraInfoToSExpression(SExpList* sexp,
-                                         FlowGraphSerializer* s) const;
 
 #define DECLARE_INSTRUCTION_TYPE_CHECK(Name, Type)                             \
   bool Is##Name() const { return (As##Name() != nullptr); }                    \
@@ -1519,9 +1498,6 @@
 
   DEFINE_INSTRUCTION_TYPE_CHECK(BlockEntry)
 
-  TO_S_EXPRESSION_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  protected:
   BlockEntryInstr(intptr_t block_id,
@@ -1822,7 +1798,6 @@
   virtual bool HasUnknownSideEffects() const { return false; }
 
   PRINT_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
 
  private:
   // Classes that have access to predecessors_ when inlining.
@@ -2269,7 +2244,6 @@
 
   PRINT_OPERANDS_TO_SUPPORT
   PRINT_TO_SUPPORT
-  TO_S_EXPRESSION_SUPPORT
 
   bool UpdateType(CompileType new_type) {
     if (type_ == nullptr) {
@@ -2382,7 +2356,6 @@
  protected:
   friend class RangeAnalysis;
   friend class Value;
-  friend class FlowGraphSerializer;  // To access type_ directly.
 
   Range* range_ = nullptr;
 
@@ -2617,7 +2590,6 @@
   virtual bool MayThrow() const { return false; }
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
@@ -2723,7 +2695,6 @@
   intptr_t offset() const { return offset_; }
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   const intptr_t offset_;
@@ -2774,7 +2745,6 @@
   intptr_t offset() const { return offset_; }
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   const intptr_t offset_;
@@ -2906,7 +2876,6 @@
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
 
  private:
   const Code& code_;
@@ -3188,7 +3157,6 @@
   }
 
   PRINT_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
 
  private:
   BlockEntryInstr* block_;
@@ -3299,7 +3267,6 @@
            (operation_cid() == other_comparison->operation_cid());
   }
 
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
 
   DEFINE_INSTRUCTION_TYPE_CHECK(Comparison)
 
@@ -3438,7 +3405,6 @@
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   PRINT_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
@@ -3592,7 +3558,6 @@
                           Register tmp = kNoRegister);
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
 
  private:
   const Object& value_;
@@ -3759,7 +3724,6 @@
   virtual Value* RedefinedValue() const;
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   const TokenPosition token_pos_;
@@ -3850,7 +3814,6 @@
   const char* ToCString() const;
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
 
  private:
   const SpecialParameterKind kind_;
@@ -3960,7 +3923,6 @@
         ArgumentsSizeWithoutTypeArgs(), argument_names());
   }
 
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
@@ -4005,7 +3967,6 @@
   Code::EntryKind entry_kind() const { return entry_kind_; }
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   const Code::EntryKind entry_kind_;
@@ -4103,8 +4064,6 @@
   Code::EntryKind entry_kind() const { return entry_kind_; }
   void set_entry_kind(Code::EntryKind value) { entry_kind_ = value; }
 
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
   DEFINE_INSTRUCTION_TYPE_CHECK(InstanceCallBase);
 
   bool receiver_is_not_smi() const { return receiver_is_not_smi_; }
@@ -4220,7 +4179,6 @@
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
   bool MatchesCoreName(const String& name);
 
@@ -4295,7 +4253,6 @@
   static TypePtr ComputeRuntimeType(const CallTargets& targets);
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   PolymorphicInstanceCallInstr(const InstructionSource& source,
@@ -4434,8 +4391,7 @@
 
   bool AttributesEqual(Instruction* other) const;
 
-  PRINT_OPERANDS_TO_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT;
+  PRINT_OPERANDS_TO_SUPPORT;
 
  private:
   Condition EmitComparisonCodeRegConstant(FlowGraphCompiler* compiler,
@@ -4868,8 +4824,6 @@
   const class BinaryFeedback& BinaryFeedback();
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   const ICData* ic_data_;
@@ -4916,7 +4870,6 @@
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
 
  private:
   const LocalVariable& local_;
@@ -5048,7 +5001,6 @@
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
 
  private:
   const LocalVariable& local_;
@@ -5098,8 +5050,6 @@
   void SetupNative();
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   void set_native_c_function(NativeFunction value) {
@@ -5292,7 +5242,6 @@
   virtual bool HasUnknownSideEffects() const { return true; }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   const TokenPosition token_pos_;
@@ -5423,8 +5372,6 @@
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   friend class JitCallSpecializer;  // For ASSERT(initialization_).
@@ -5684,7 +5631,6 @@
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   const bool index_unboxed_;
@@ -5988,7 +5934,6 @@
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   compiler::Assembler::CanBeSmi CanValueBeSmi() const {
@@ -6170,8 +6115,6 @@
   }
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
@@ -6639,8 +6582,6 @@
   virtual bool AttributesEqual(Instruction* other) const;
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   intptr_t OffsetInBytes() const { return slot().offset_in_bytes(); }
@@ -7469,7 +7410,6 @@
   }
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
 
   DECLARE_COMPARISON_INSTRUCTION(DoubleTestOp)
 
@@ -7642,7 +7582,6 @@
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
 
   DECLARE_INSTRUCTION(CheckedSmiOp)
 
@@ -7767,7 +7706,6 @@
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
 
   DEFINE_INSTRUCTION_TYPE_CHECK(BinaryIntegerOp)
 
@@ -8220,7 +8158,6 @@
   }
 
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   const TokenPosition token_pos_;
@@ -8792,7 +8729,6 @@
 
   virtual Value* RedefinedValue() const;
 
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
   PRINT_OPERANDS_TO_SUPPORT
 
@@ -9323,8 +9259,6 @@
 
   DECLARE_INSTRUCTION(SimdOp)
   PRINT_OPERANDS_TO_SUPPORT
-  ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
-  ADD_EXTRA_INFO_TO_S_EXPRESSION_SUPPORT
 
  private:
   SimdOpInstr(Kind kind, intptr_t deopt_id)
@@ -9539,7 +9473,6 @@
                        Definition* result) const;
 
   void PrintTo(BaseTextBuffer* f) const;
-  SExpression* ToSExpression(FlowGraphSerializer* s) const;
   const char* ToCString() const;
 
   // Deep copy an environment.  The 'length' parameter may be less than the
diff --git a/runtime/vm/compiler/backend/il_deserializer.cc b/runtime/vm/compiler/backend/il_deserializer.cc
deleted file mode 100644
index eb7f1fa..0000000
--- a/runtime/vm/compiler/backend/il_deserializer.cc
+++ /dev/null
@@ -1,2520 +0,0 @@
-// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-#include "vm/compiler/backend/il_deserializer.h"
-
-#include "vm/compiler/backend/il_serializer.h"
-#include "vm/compiler/backend/range_analysis.h"
-#include "vm/compiler/call_specializer.h"
-#include "vm/compiler/frontend/base_flow_graph_builder.h"
-#include "vm/compiler/jit/compiler.h"
-#include "vm/flags.h"
-#include "vm/json_writer.h"
-#include "vm/os.h"
-
-namespace dart {
-
-DEFINE_FLAG(bool,
-            trace_round_trip_serialization,
-            false,
-            "Print out tracing information during round trip serialization.");
-DEFINE_FLAG(bool,
-            print_json_round_trip_results,
-            false,
-            "Print out results of each round trip serialization in JSON form.");
-
-// Contains the contents of a single round-trip result.
-struct RoundTripResults : public ValueObject {
-  explicit RoundTripResults(Zone* zone, const Function& func)
-      : function(func), unhandled(zone, 2) {}
-
-  // The function for which a flow graph was being parsed.
-  const Function& function;
-  // Whether the round trip succeeded.
-  bool success = false;
-  // An array of unhandled instructions found in the flow graph.
-  GrowableArray<Instruction*> unhandled;
-  // The serialized form of the flow graph, if computed.
-  SExpression* serialized = nullptr;
-  // The error information from the deserializer, if an error occurred.
-  const char* error_message = nullptr;
-  SExpression* error_sexp = nullptr;
-};
-
-// Return a textual description of how to find the sub-expression [to_find]
-// inside a [root] S-Expression.
-static const char* GetSExpressionPosition(Zone* zone,
-                                          SExpression* root,
-                                          SExpression* to_find) {
-  // The S-expression to find _is_ the root, so no description is needed.
-  if (root == to_find) return "";
-  // The S-expression to find cannot be a sub-expression of the given root,
-  // so return nullptr to signal this.
-  if (!root->IsList()) return nullptr;
-  auto const list = root->AsList();
-  for (intptr_t i = 0, n = list->Length(); i < n; i++) {
-    if (auto const str = GetSExpressionPosition(zone, list->At(i), to_find)) {
-      return OS::SCreate(zone, "element %" Pd "%s%s", i,
-                         *str == '\0' ? "" : " -> ", str);
-    }
-  }
-  auto it = list->ExtraIterator();
-  while (auto kv = it.Next()) {
-    if (auto const str = GetSExpressionPosition(zone, kv->value, to_find)) {
-      return OS::SCreate(zone, "label %s%s%s", kv->key,
-                         *str == '\0' ? "" : " -> ", str);
-    }
-  }
-  return nullptr;
-}
-
-static void PrintRoundTripResults(Zone* zone, const RoundTripResults& results) {
-  // A few checks to make sure we'll print out enough info. First, if there are
-  // no unhandled instructions, then we should have serialized the flow graph.
-  ASSERT(!results.unhandled.is_empty() || results.serialized != nullptr);
-  // If we failed, then either there are unhandled instructions or we have
-  // an appropriate error message and sexp from the FlowGraphDeserializer.
-  ASSERT(results.success || !results.unhandled.is_empty() ||
-         (results.error_message != nullptr && results.error_sexp != nullptr));
-
-  JSONWriter js;
-
-  js.OpenObject();
-  js.PrintProperty("function", results.function.ToFullyQualifiedCString());
-  js.PrintPropertyBool("success", results.success);
-
-  if (!results.unhandled.is_empty()) {
-    CStringMap<intptr_t> count_map(zone);
-    for (auto inst : results.unhandled) {
-      auto const name = inst->DebugName();
-      auto const old_count = count_map.LookupValue(name);
-      count_map.Update({name, old_count + 1});
-    }
-
-    auto count_it = count_map.GetIterator();
-    js.OpenObject("unhandled");
-    while (auto kv = count_it.Next()) {
-      js.PrintProperty64(kv->key, kv->value);
-    }
-    js.CloseObject();
-  }
-
-  if (results.serialized != nullptr) {
-    TextBuffer buf(1000);
-    results.serialized->SerializeTo(zone, &buf, "");
-    js.PrintProperty("serialized", buf.buffer());
-  }
-
-  if (results.error_message != nullptr) {
-    js.OpenObject("error");
-    js.PrintProperty("message", results.error_message);
-
-    ASSERT(results.error_sexp != nullptr);
-    TextBuffer buf(1000);
-    results.error_sexp->SerializeTo(zone, &buf, "");
-    js.PrintProperty("expression", buf.buffer());
-
-    auto const sexp_position =
-        GetSExpressionPosition(zone, results.serialized, results.error_sexp);
-    js.PrintProperty("path", sexp_position);
-    js.CloseObject();
-  }
-
-  js.CloseObject();
-  THR_Print("Results of round trip serialization: %s\n", js.buffer()->buffer());
-}
-
-void FlowGraphDeserializer::RoundTripSerialization(CompilerPassState* state) {
-  auto const flow_graph = state->flow_graph();
-
-  // The deserialized flow graph must be in the same zone as the original flow
-  // graph, to ensure it has the right lifetime. Thus, we leave an explicit
-  // use of [flow_graph->zone()] in the deserializer construction.
-  //
-  // Otherwise, it would be nice to use a StackZone to limit the lifetime of the
-  // serialized form (and other values created with this [zone] variable), since
-  // it only needs to live for the dynamic extent of this method.
-  //
-  // However, creating a StackZone for it also changes the zone associated with
-  // the thread. Also, some parts of the VM used in later updates to the
-  // deserializer implicitly pick up the zone to use either from a passed-in
-  // thread or the current thread instead of taking an explicit zone.
-  //
-  // For now, just serialize into the same zone as the original flow graph, and
-  // we can revisit this if this causes a performance issue or if we can ensure
-  // that those VM parts mentioned can be passed an explicit zone.
-  Zone* const zone = flow_graph->zone();
-
-  // Final flow graph, if we successfully serialize and deserialize.
-  FlowGraph* new_graph = nullptr;
-
-  // Stored information for printing results if requested.
-  RoundTripResults results(zone, flow_graph->function());
-
-  FlowGraphDeserializer::AllUnhandledInstructions(flow_graph,
-                                                  &results.unhandled);
-  if (results.unhandled.is_empty()) {
-    results.serialized = FlowGraphSerializer::SerializeToSExp(zone, flow_graph);
-
-    if (FLAG_trace_round_trip_serialization && results.serialized != nullptr) {
-      TextBuffer buf(1000);
-      results.serialized->SerializeTo(zone, &buf, "");
-      THR_Print("Serialized flow graph:\n%s\n", buf.buffer());
-    }
-
-    // For the deserializer, use the thread from the compiler pass and zone
-    // associated with the existing flow graph to make sure the new flow graph
-    // has the right lifetime.
-    FlowGraphDeserializer d(state->thread, flow_graph->zone(),
-                            results.serialized, &flow_graph->parsed_function());
-    new_graph = d.ParseFlowGraph();
-    if (new_graph == nullptr) {
-      ASSERT(d.error_message() != nullptr && d.error_sexp() != nullptr);
-      if (FLAG_trace_round_trip_serialization) {
-        THR_Print("Failure during deserialization: %s\n", d.error_message());
-        THR_Print("At S-expression %s\n", d.error_sexp()->ToCString(zone));
-        if (auto const pos = GetSExpressionPosition(zone, results.serialized,
-                                                    d.error_sexp())) {
-          THR_Print("Path from root: %s\n", pos);
-        }
-      }
-      results.error_message = d.error_message();
-      results.error_sexp = d.error_sexp();
-    } else {
-      if (FLAG_trace_round_trip_serialization) {
-        THR_Print("Successfully deserialized graph for %s\n",
-                  results.serialized->AsList()->At(1)->AsSymbol()->value());
-      }
-      results.success = true;
-    }
-  } else if (FLAG_trace_round_trip_serialization) {
-    THR_Print("Cannot serialize graph due to instruction: %s\n",
-              results.unhandled.At(0)->DebugName());
-  }
-
-  if (FLAG_print_json_round_trip_results) PrintRoundTripResults(zone, results);
-
-  if (new_graph != nullptr) {
-    state->set_flow_graph(new_graph);
-  }
-}
-
-#define HANDLED_CASE(name)                                                     \
-  if (inst->Is##name()) return true;
-bool FlowGraphDeserializer::IsHandledInstruction(Instruction* inst) {
-  if (auto const const_inst = inst->AsConstant()) {
-    return IsHandledConstant(const_inst->value());
-  }
-  FOR_EACH_HANDLED_BLOCK_TYPE_IN_DESERIALIZER(HANDLED_CASE)
-  FOR_EACH_HANDLED_INSTRUCTION_IN_DESERIALIZER(HANDLED_CASE)
-  return false;
-}
-#undef HANDLED_CASE
-
-void FlowGraphDeserializer::AllUnhandledInstructions(
-    const FlowGraph* graph,
-    GrowableArray<Instruction*>* unhandled) {
-  ASSERT(graph != nullptr);
-  ASSERT(unhandled != nullptr);
-  for (auto block_it = graph->reverse_postorder_iterator(); !block_it.Done();
-       block_it.Advance()) {
-    auto const entry = block_it.Current();
-    if (!IsHandledInstruction(entry)) unhandled->Add(entry);
-    // Check that the Phi instructions in JoinEntrys do not have pair
-    // representation.
-    if (auto const join_block = entry->AsJoinEntry()) {
-      auto const phis = join_block->phis();
-      auto const length = ((phis == nullptr) ? 0 : phis->length());
-      for (intptr_t i = 0; i < length; i++) {
-        auto const current = phis->At(i);
-        for (intptr_t j = 0; j < current->InputCount(); j++) {
-          if (current->InputAt(j)->definition()->HasPairRepresentation()) {
-            unhandled->Add(current);
-          }
-        }
-      }
-    }
-    if (auto const def_block = entry->AsBlockEntryWithInitialDefs()) {
-      auto const defs = def_block->initial_definitions();
-      for (intptr_t i = 0; i < defs->length(); i++) {
-        auto const current = defs->At(i);
-        if (!IsHandledInstruction(current)) unhandled->Add(current);
-      }
-    }
-    for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
-      auto current = it.Current();
-      // We handle branches, so we need to check the comparison instruction.
-      if (current->IsBranch()) current = current->AsBranch()->comparison();
-      if (!IsHandledInstruction(current)) unhandled->Add(current);
-    }
-  }
-}
-
-// Keep in sync with work in ParseDartValue. Right now, this is just a shallow
-// check, not a deep one.
-bool FlowGraphDeserializer::IsHandledConstant(const Object& obj) {
-  if (obj.IsArray()) return Array::Cast(obj).IsImmutable();
-  return obj.IsNull() || obj.IsClass() || obj.IsFunction() || obj.IsField() ||
-         obj.IsInstance();
-}
-
-SExpression* FlowGraphDeserializer::Retrieve(SExpList* list, intptr_t index) {
-  if (list == nullptr) return nullptr;
-  if (list->Length() <= index) {
-    StoreError(list, "expected at least %" Pd " element(s) in list", index + 1);
-    return nullptr;
-  }
-  auto const elem = list->At(index);
-  if (elem == nullptr) {
-    StoreError(list, "null value at index %" Pd "", index);
-  }
-  return elem;
-}
-
-SExpression* FlowGraphDeserializer::Retrieve(SExpList* list, const char* key) {
-  if (list == nullptr) return nullptr;
-  if (!list->ExtraHasKey(key)) {
-    StoreError(list, "expected an extra info entry for key %s", key);
-    return nullptr;
-  }
-  auto const elem = list->ExtraLookupValue(key);
-  if (elem == nullptr) {
-    StoreError(list, "null value for key %s", key);
-  }
-  return elem;
-}
-
-FlowGraph* FlowGraphDeserializer::ParseFlowGraph() {
-  auto const root = CheckTaggedList(root_sexp_, "FlowGraph");
-  if (root == nullptr) return nullptr;
-
-  intptr_t deopt_id = DeoptId::kNone;
-  if (auto const deopt_id_sexp =
-          CheckInteger(root->ExtraLookupValue("deopt_id"))) {
-    deopt_id = deopt_id_sexp->value();
-  }
-  EntryInfo common_info = {0, kInvalidTryIndex, deopt_id};
-
-  auto const graph = DeserializeGraphEntry(root, common_info);
-
-  PrologueInfo pi(-1, -1);
-  flow_graph_ = new (zone()) FlowGraph(*parsed_function_, graph, 0, pi);
-  flow_graph_->CreateCommonConstants();
-
-  intptr_t pos = 2;
-  if (auto const pool = CheckTaggedList(Retrieve(root, pos), "Constants")) {
-    if (!ParseConstantPool(pool)) return nullptr;
-    pos++;
-  }
-
-  // The deopt environment for the graph entry may use entries from the
-  // constant pool, so that must be parsed first.
-  if (auto const env_sexp = CheckList(root->ExtraLookupValue("env"))) {
-    current_block_ = graph;
-    auto const env = ParseEnvironment(env_sexp);
-    if (env == nullptr) return nullptr;
-    env->DeepCopyTo(zone(), graph);
-  }
-
-  auto const entries_sexp = CheckTaggedList(Retrieve(root, pos), "Entries");
-  if (!ParseEntries(entries_sexp)) return nullptr;
-  pos++;
-
-  // Now prime the block worklist with entries. We keep the block worklist
-  // in reverse order so that we can just pop the next block for content
-  // parsing off the end.
-  BlockWorklist block_worklist(zone(), entries_sexp->Length() - 1);
-
-  const auto& indirect_entries = graph->indirect_entries();
-  for (auto indirect_entry : indirect_entries) {
-    block_worklist.Add(indirect_entry->block_id());
-  }
-
-  const auto& catch_entries = graph->catch_entries();
-  for (auto catch_entry : catch_entries) {
-    block_worklist.Add(catch_entry->block_id());
-  }
-
-  if (auto const osr_entry = graph->osr_entry()) {
-    block_worklist.Add(osr_entry->block_id());
-  }
-  if (auto const unchecked_entry = graph->unchecked_entry()) {
-    block_worklist.Add(unchecked_entry->block_id());
-  }
-  if (auto const normal_entry = graph->normal_entry()) {
-    block_worklist.Add(normal_entry->block_id());
-  }
-
-  if (!ParseBlocks(root, pos, &block_worklist)) return nullptr;
-
-  // Before we return the new graph, make sure all definitions were found for
-  // all pending values.
-  if (values_map_.Length() > 0) {
-    auto it = values_map_.GetIterator();
-    auto const kv = it.Next();
-    ASSERT(kv->value->length() > 0);
-    const auto& value_info = kv->value->At(0);
-    StoreError(value_info.sexp, "no definition found for use in flow graph");
-    return nullptr;
-  }
-
-  flow_graph_->set_max_block_id(max_block_id_);
-  // The highest numbered SSA temp might need two slots (e.g. for unboxed
-  // integers on 32-bit platforms), so we add 2 to the highest seen SSA temp
-  // index to get to the new current SSA temp index. In cases where the highest
-  // numbered SSA temp originally had only one slot assigned, this can result
-  // in different SSA temp numbering in later passes between the original and
-  // deserialized graphs.
-  flow_graph_->set_current_ssa_temp_index(max_ssa_index_ + 2);
-  // Now that the deserializer has finished re-creating all the blocks in the
-  // flow graph, the blocks must be rediscovered. In addition, if ComputeSSA
-  // has already been run, dominators must be recomputed as well.
-  flow_graph_->DiscoverBlocks();
-  // Currently we only handle SSA graphs, so always do this.
-  GrowableArray<BitVector*> dominance_frontier;
-  flow_graph_->ComputeDominators(&dominance_frontier);
-
-  return flow_graph_;
-}
-
-bool FlowGraphDeserializer::ParseConstantPool(SExpList* pool) {
-  ASSERT(flow_graph_ != nullptr);
-  if (pool == nullptr) return false;
-  // Definitions in the constant pool may refer to later definitions. However,
-  // there should be no cycles possible between constant objects, so using a
-  // worklist algorithm we should always be able to make progress.
-  // Since we will not be adding new definitions, we make the initial size of
-  // the worklist the number of definitions in the constant pool.
-  GrowableArray<SExpList*> worklist(zone(), pool->Length() - 1);
-  // In order to ensure that the definition order is the same in the original
-  // flow graph, we can't just simply call GetConstant() whenever we
-  // successfully parse a constant. Instead, we'll create a stand-in
-  // ConstantInstr that we can temporarily stick in the definition_map_, and
-  // then once finished we'll go back through, add the constants via
-  // GetConstant() and parse any extra information.
-  DirectChainedHashMap<RawPointerKeyValueTrait<SExpList, ConstantInstr*>>
-      parsed_constants(zone());
-  // We keep old_worklist in reverse order so that we can just RemoveLast
-  // to get elements in their original order.
-  for (intptr_t i = pool->Length() - 1; i > 0; i--) {
-    const auto def_sexp = CheckTaggedList(pool->At(i), "def");
-    if (def_sexp == nullptr) return false;
-    worklist.Add(def_sexp);
-  }
-  while (true) {
-    const intptr_t worklist_len = worklist.length();
-    GrowableArray<SExpList*> parse_failures(zone(), worklist_len);
-    while (!worklist.is_empty()) {
-      const auto def_sexp = worklist.RemoveLast();
-      auto& obj = Object::ZoneHandle(zone());
-      if (!ParseDartValue(Retrieve(def_sexp, 2), &obj)) {
-        parse_failures.Add(def_sexp);
-        continue;
-      }
-      ConstantInstr* def = new (zone()) ConstantInstr(obj);
-      // Instead of parsing the whole definition, just get the SSA index so
-      // we can insert it into the definition_map_.
-      intptr_t index;
-      auto const name_sexp = CheckSymbol(Retrieve(def_sexp, 1));
-      if (!ParseSSATemp(name_sexp, &index)) return false;
-      def->set_ssa_temp_index(index);
-      ASSERT(!definition_map_.HasKey(index));
-      definition_map_.Insert(index, def);
-      parsed_constants.Insert({def_sexp, def});
-    }
-    if (parse_failures.is_empty()) break;
-    // We've gone through the whole worklist without success, so return
-    // the last error we encountered.
-    if (parse_failures.length() == worklist_len) return false;
-    // worklist was added to in order, so we need to reverse its contents
-    // when we add them to old_worklist.
-    while (!parse_failures.is_empty()) {
-      worklist.Add(parse_failures.RemoveLast());
-    }
-  }
-  // Now loop back through the constant pool definition S-expressions and
-  // get the real ConstantInstrs the flow graph will be using and finish
-  // parsing.
-  for (intptr_t i = 1; i < pool->Length(); i++) {
-    auto const def_sexp = CheckTaggedList(pool->At(i));
-    auto const temp_def = parsed_constants.LookupValue(def_sexp);
-    ASSERT(temp_def != nullptr);
-    // Remove the temporary definition from definition_map_ so this doesn't get
-    // flagged as a redefinition.
-    definition_map_.Remove(temp_def->ssa_temp_index());
-    ConstantInstr* real_def = flow_graph_->GetConstant(temp_def->value());
-    if (!ParseDefinitionWithParsedBody(def_sexp, real_def)) return false;
-    ASSERT(temp_def->ssa_temp_index() == real_def->ssa_temp_index());
-  }
-  return true;
-}
-
-bool FlowGraphDeserializer::ParseEntries(SExpList* list) {
-  ASSERT(flow_graph_ != nullptr);
-  if (list == nullptr) return false;
-  for (intptr_t i = 1; i < list->Length(); i++) {
-    const auto entry = CheckTaggedList(Retrieve(list, i));
-    if (entry == nullptr) return false;
-    intptr_t block_id;
-    if (!ParseBlockId(CheckSymbol(Retrieve(entry, 1)), &block_id)) {
-      return false;
-    }
-    if (block_map_.LookupValue(block_id) != nullptr) {
-      StoreError(entry->At(1), "multiple entries for block found");
-      return false;
-    }
-    const auto tag = entry->Tag();
-    if (ParseBlockHeader(entry, block_id, tag) == nullptr) return false;
-  }
-  return true;
-}
-
-bool FlowGraphDeserializer::ParseBlocks(SExpList* list,
-                                        intptr_t pos,
-                                        BlockWorklist* worklist) {
-  // First, ensure that all the block headers have been parsed. Set up a
-  // map from block IDs to S-expressions and the max_block_id while we're at it.
-  IntMap<SExpList*> block_sexp_map(zone());
-  for (intptr_t i = pos, n = list->Length(); i < n; i++) {
-    auto const block_sexp = CheckTaggedList(Retrieve(list, i), "Block");
-    intptr_t block_id;
-    if (!ParseBlockId(CheckSymbol(Retrieve(block_sexp, 1)), &block_id)) {
-      return false;
-    }
-    if (block_sexp_map.LookupValue(block_id) != nullptr) {
-      StoreError(block_sexp->At(1), "multiple definitions of block found");
-      return false;
-    }
-    block_sexp_map.Insert(block_id, block_sexp);
-    auto const type_tag =
-        CheckSymbol(block_sexp->ExtraLookupValue("block_type"));
-    // Entry block headers are already parsed, but others aren't.
-    if (block_map_.LookupValue(block_id) == nullptr) {
-      if (ParseBlockHeader(block_sexp, block_id, type_tag) == nullptr) {
-        return false;
-      }
-    }
-    if (max_block_id_ < block_id) max_block_id_ = block_id;
-  }
-
-  // Now start parsing the contents of blocks from the worklist. We use an
-  // IntMap to keep track of what blocks have already been fully parsed.
-  IntMap<bool> fully_parsed_block_map(zone());
-  while (!worklist->is_empty()) {
-    auto const block_id = worklist->RemoveLast();
-
-    // If we've already encountered this block, skip it.
-    if (fully_parsed_block_map.LookupValue(block_id)) continue;
-
-    auto const block_sexp = block_sexp_map.LookupValue(block_id);
-    ASSERT(block_sexp != nullptr);
-
-    current_block_ = block_map_.LookupValue(block_id);
-    ASSERT(current_block_ != nullptr);
-    ASSERT(current_block_->PredecessorCount() > 0);
-
-    if (!ParseBlockContents(block_sexp, worklist)) return false;
-
-    // Mark this block as done.
-    fully_parsed_block_map.Insert(block_id, true);
-  }
-
-  // Double-check that all blocks were reached by the worklist algorithm.
-  auto it = block_sexp_map.GetIterator();
-  while (auto kv = it.Next()) {
-    if (!fully_parsed_block_map.LookupValue(kv->key)) {
-      StoreError(kv->value, "block unreachable in flow graph");
-      return false;
-    }
-  }
-
-  return true;
-}
-
-bool FlowGraphDeserializer::ParseInitialDefinitions(SExpList* list) {
-  ASSERT(current_block_ != nullptr);
-  ASSERT(current_block_->IsBlockEntryWithInitialDefs());
-  auto const block = current_block_->AsBlockEntryWithInitialDefs();
-  if (list == nullptr) return false;
-  for (intptr_t i = 2; i < list->Length(); i++) {
-    const auto def_sexp = CheckTaggedList(Retrieve(list, i), "def");
-    const auto def = ParseDefinition(def_sexp);
-    if (def == nullptr) return false;
-    flow_graph_->AddToInitialDefinitions(block, def);
-  }
-  return true;
-}
-
-BlockEntryInstr* FlowGraphDeserializer::ParseBlockHeader(SExpList* list,
-                                                         intptr_t block_id,
-                                                         SExpSymbol* tag) {
-  ASSERT(flow_graph_ != nullptr);
-  // We should only parse block headers once.
-  ASSERT(block_map_.LookupValue(block_id) == nullptr);
-  if (list == nullptr) return nullptr;
-
-#if defined(DEBUG)
-  intptr_t parsed_block_id;
-  auto const id_sexp = CheckSymbol(Retrieve(list, 1));
-  if (!ParseBlockId(id_sexp, &parsed_block_id)) return nullptr;
-  ASSERT(block_id == parsed_block_id);
-#endif
-
-  auto const kind = FlowGraphSerializer::BlockEntryTagToKind(tag);
-
-  intptr_t deopt_id = DeoptId::kNone;
-  if (auto const deopt_int = CheckInteger(list->ExtraLookupValue("deopt_id"))) {
-    deopt_id = deopt_int->value();
-  }
-  intptr_t try_index = kInvalidTryIndex;
-  if (auto const try_int = CheckInteger(list->ExtraLookupValue("try_index"))) {
-    try_index = try_int->value();
-  }
-
-  BlockEntryInstr* block = nullptr;
-  EntryInfo common_info = {block_id, try_index, deopt_id};
-  switch (kind) {
-    case FlowGraphSerializer::kTarget:
-      block = DeserializeTargetEntry(list, common_info);
-      break;
-    case FlowGraphSerializer::kNormal:
-      block = DeserializeFunctionEntry(list, common_info);
-      if (block != nullptr) {
-        auto const graph = flow_graph_->graph_entry();
-        graph->set_normal_entry(block->AsFunctionEntry());
-      }
-      break;
-    case FlowGraphSerializer::kUnchecked: {
-      block = DeserializeFunctionEntry(list, common_info);
-      if (block != nullptr) {
-        auto const graph = flow_graph_->graph_entry();
-        graph->set_unchecked_entry(block->AsFunctionEntry());
-      }
-      break;
-    }
-    case FlowGraphSerializer::kJoin:
-      block = DeserializeJoinEntry(list, common_info);
-      break;
-    case FlowGraphSerializer::kInvalid:
-      StoreError(tag, "invalid block entry tag");
-      return nullptr;
-    default:
-      StoreError(tag, "unhandled block type");
-      return nullptr;
-  }
-  if (block == nullptr) return nullptr;
-
-  block_map_.Insert(block_id, block);
-  return block;
-}
-
-bool FlowGraphDeserializer::ParsePhis(SExpList* list) {
-  ASSERT(current_block_ != nullptr && current_block_->IsJoinEntry());
-  auto const join = current_block_->AsJoinEntry();
-  const intptr_t start_pos = 2;
-  auto const end_pos = SkipPhis(list);
-  if (end_pos < start_pos) return false;
-
-  for (intptr_t i = start_pos; i < end_pos; i++) {
-    auto const def_sexp = CheckTaggedList(Retrieve(list, i), "def");
-    auto const phi_sexp = CheckTaggedList(Retrieve(def_sexp, 2), "Phi");
-    // SkipPhis should already have checked which instructions, if any,
-    // are Phi definitions.
-    ASSERT(phi_sexp != nullptr);
-
-    // This is a generalization of FlowGraph::AddPhi where we let ParseValue
-    // create the values (as they may contain type information).
-    auto const phi = new (zone()) PhiInstr(join, phi_sexp->Length() - 1);
-    phi->mark_alive();
-    for (intptr_t i = 0, n = phi_sexp->Length() - 1; i < n; i++) {
-      auto const val = ParseValue(Retrieve(phi_sexp, i + 1));
-      if (val == nullptr) return false;
-      phi->SetInputAt(i, val);
-      val->definition()->AddInputUse(val);
-    }
-    join->InsertPhi(phi);
-
-    if (!ParseDefinitionWithParsedBody(def_sexp, phi)) return false;
-  }
-
-  return true;
-}
-
-intptr_t FlowGraphDeserializer::SkipPhis(SExpList* list) {
-  // All blocks are S-exps of the form (Block B# inst...), so skip the first
-  // two entries and then skip any Phi definitions.
-  for (intptr_t i = 2, n = list->Length(); i < n; i++) {
-    auto const def_sexp = CheckTaggedList(Retrieve(list, i), "def");
-    if (def_sexp == nullptr) return i;
-    auto const phi_sexp = CheckTaggedList(Retrieve(def_sexp, 2), "Phi");
-    if (phi_sexp == nullptr) return i;
-  }
-
-  StoreError(list, "block is empty or contains only Phi definitions");
-  return -1;
-}
-
-bool FlowGraphDeserializer::ParseBlockContents(SExpList* list,
-                                               BlockWorklist* worklist) {
-  ASSERT(current_block_ != nullptr);
-
-  // Parse any Phi definitions now before parsing the block environment.
-  if (current_block_->IsJoinEntry()) {
-    if (!ParsePhis(list)) return false;
-  }
-
-  // For blocks with initial definitions or phi definitions, this needs to be
-  // done after those are parsed. In addition, block environments can also use
-  // definitions from dominating blocks, so we need the contents of dominating
-  // blocks to first be parsed.
-  //
-  // However, we must parse the environment before parsing any instructions
-  // in the body of the block to ensure we don't mistakenly allow local
-  // definitions to appear in the environment.
-  if (auto const env_sexp = CheckList(list->ExtraLookupValue("env"))) {
-    auto const env = ParseEnvironment(env_sexp);
-    if (env == nullptr) return false;
-    env->DeepCopyTo(zone(), current_block_);
-  }
-
-  auto const pos = SkipPhis(list);
-  if (pos < 2) return false;
-  Instruction* last_inst = current_block_;
-  for (intptr_t i = pos, n = list->Length(); i < n; i++) {
-    auto const inst = ParseInstruction(CheckTaggedList(Retrieve(list, i)));
-    if (inst == nullptr) return false;
-    last_inst = last_inst->AppendInstruction(inst);
-  }
-
-  ASSERT(last_inst != nullptr && last_inst != current_block_);
-  if (last_inst->SuccessorCount() > 0) {
-    for (intptr_t i = last_inst->SuccessorCount() - 1; i >= 0; i--) {
-      auto const succ_block = last_inst->SuccessorAt(i);
-      succ_block->AddPredecessor(current_block_);
-      worklist->Add(succ_block->block_id());
-    }
-  }
-
-  return true;
-}
-
-bool FlowGraphDeserializer::ParseDefinitionWithParsedBody(SExpList* list,
-                                                          Definition* def) {
-  if (auto const type_sexp =
-          CheckTaggedList(list->ExtraLookupValue("type"), "CompileType")) {
-    CompileType* typ = ParseCompileType(type_sexp);
-    if (typ == nullptr) return false;
-    def->UpdateType(*typ);
-  }
-
-  if (auto const range_sexp =
-          CheckTaggedList(list->ExtraLookupValue("range"), "Range")) {
-    Range range;
-    if (!ParseRange(range_sexp, &range)) return false;
-    def->set_range(range);
-  }
-
-  auto const name_sexp = CheckSymbol(Retrieve(list, 1));
-  if (name_sexp == nullptr) return false;
-
-  // If the name is "_", this is a subclass of Definition where there's no real
-  // "result" that's being bound. We were just here to add Definition-specific
-  // extra info.
-  if (name_sexp->Equals("_")) return true;
-
-  intptr_t index;
-  if (ParseSSATemp(name_sexp, &index)) {
-    if (definition_map_.HasKey(index)) {
-      StoreError(list, "multiple definitions for the same SSA index");
-      return false;
-    }
-    def->set_ssa_temp_index(index);
-    if (index > max_ssa_index_) max_ssa_index_ = index;
-  } else {
-    // TODO(sstrickl): Add temp support for non-SSA computed graphs.
-    StoreError(list, "unhandled name for definition");
-    return false;
-  }
-
-  definition_map_.Insert(index, def);
-  if (!FixPendingValues(index, def)) return false;
-  return true;
-}
-
-Definition* FlowGraphDeserializer::ParseDefinition(SExpList* list) {
-  if (list == nullptr) return nullptr;
-  ASSERT(list->Tag() != nullptr && list->Tag()->Equals("def"));
-  auto const inst_sexp = CheckTaggedList(Retrieve(list, 2));
-  auto const inst = ParseInstruction(inst_sexp);
-  if (inst == nullptr) return nullptr;
-  if (auto const def = inst->AsDefinition()) {
-    if (!ParseDefinitionWithParsedBody(list, def)) return nullptr;
-    return def;
-  } else {
-    StoreError(list, "instruction cannot be body of definition");
-    return nullptr;
-  }
-}
-
-Instruction* FlowGraphDeserializer::ParseInstruction(SExpList* list) {
-  if (list == nullptr) return nullptr;
-  auto const tag = list->Tag();
-  if (tag->Equals("def")) return ParseDefinition(list);
-
-  intptr_t deopt_id = DeoptId::kNone;
-  if (auto const deopt_int = CheckInteger(list->ExtraLookupValue("deopt_id"))) {
-    deopt_id = deopt_int->value();
-  }
-  TokenPosition token_pos = TokenPosition::kNoSource;
-  if (auto const token_int =
-          CheckInteger(list->ExtraLookupValue("token_pos"))) {
-    token_pos = TokenPosition::Deserialize(token_int->value());
-  }
-  intptr_t inlining_id = -1;
-  if (auto const inlining_int =
-          CheckInteger(list->ExtraLookupValue("inlining_id"))) {
-    inlining_id = inlining_int->value();
-  }
-  InstrInfo common_info = {deopt_id, InstructionSource(token_pos, inlining_id)};
-
-  // Parse the environment before handling the instruction, as we may have
-  // references to PushArguments and parsing the instruction may pop
-  // PushArguments off the stack.
-  // TODO(alexmarkov): revise as it may not be needed anymore.
-  Environment* env = nullptr;
-  if (auto const env_sexp = CheckList(list->ExtraLookupValue("env"))) {
-    env = ParseEnvironment(env_sexp);
-    if (env == nullptr) return nullptr;
-  }
-
-  Instruction* inst = nullptr;
-
-#define HANDLE_CASE(name)                                                      \
-  case kHandled##name:                                                         \
-    inst = Deserialize##name(list, common_info);                               \
-    break;
-  switch (HandledInstructionForTag(tag)) {
-    FOR_EACH_HANDLED_INSTRUCTION_IN_DESERIALIZER(HANDLE_CASE)
-    case kHandledInvalid:
-      StoreError(tag, "unhandled instruction");
-      return nullptr;
-  }
-#undef HANDLE_CASE
-
-  if (inst == nullptr) return nullptr;
-  if (env != nullptr) env->DeepCopyTo(zone(), inst);
-  return inst;
-}
-
-FunctionEntryInstr* FlowGraphDeserializer::DeserializeFunctionEntry(
-    SExpList* sexp,
-    const EntryInfo& info) {
-  ASSERT(flow_graph_ != nullptr);
-  auto const graph = flow_graph_->graph_entry();
-  auto const block = new (zone())
-      FunctionEntryInstr(graph, info.block_id, info.try_index, info.deopt_id);
-  current_block_ = block;
-  if (!ParseInitialDefinitions(sexp)) return nullptr;
-  return block;
-}
-
-GraphEntryInstr* FlowGraphDeserializer::DeserializeGraphEntry(
-    SExpList* sexp,
-    const EntryInfo& info) {
-  auto const name_sexp = CheckSymbol(Retrieve(sexp, 1));
-  // TODO(sstrickl): If the FlowGraphDeserializer was constructed with a
-  // non-null ParsedFunction, we should check that the name matches here.
-  // If not, then we should create an appropriate ParsedFunction here.
-  if (name_sexp == nullptr) return nullptr;
-
-  intptr_t osr_id = Compiler::kNoOSRDeoptId;
-  if (auto const osr_id_sexp = CheckInteger(sexp->ExtraLookupValue("osr_id"))) {
-    osr_id = osr_id_sexp->value();
-  }
-
-  ASSERT(parsed_function_ != nullptr);
-  return new (zone()) GraphEntryInstr(*parsed_function_, osr_id, info.deopt_id);
-}
-
-JoinEntryInstr* FlowGraphDeserializer::DeserializeJoinEntry(
-    SExpList* sexp,
-    const EntryInfo& info) {
-  return new (zone())
-      JoinEntryInstr(info.block_id, info.try_index, info.deopt_id);
-}
-
-TargetEntryInstr* FlowGraphDeserializer::DeserializeTargetEntry(
-    SExpList* sexp,
-    const EntryInfo& info) {
-  return new (zone())
-      TargetEntryInstr(info.block_id, info.try_index, info.deopt_id);
-}
-
-AllocateObjectInstr* FlowGraphDeserializer::DeserializeAllocateObject(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  auto& cls = Class::ZoneHandle(zone());
-  auto const cls_sexp = CheckTaggedList(Retrieve(sexp, 1), "Class");
-  if (!ParseClass(cls_sexp, &cls)) return nullptr;
-
-  Value* type_arguments = nullptr;
-  if (cls.NumTypeArguments() > 0) {
-    type_arguments = ParseValue(Retrieve(sexp, 2));
-    if (type_arguments == nullptr) return nullptr;
-  }
-
-  auto const inst =
-      new (zone()) AllocateObjectInstr(info.source, cls, type_arguments);
-
-  if (auto const closure_sexp = CheckTaggedList(
-          sexp->ExtraLookupValue("closure_function"), "Function")) {
-    auto& closure_function = Function::Handle(zone());
-    if (!ParseFunction(closure_sexp, &closure_function)) return nullptr;
-    inst->set_closure_function(closure_function);
-  }
-
-  if (auto const ident_sexp = CheckSymbol(sexp->ExtraLookupValue("identity"))) {
-    auto id = AliasIdentity::Unknown();
-    if (!AliasIdentity::Parse(ident_sexp->value(), &id)) {
-      return nullptr;
-    }
-    inst->SetIdentity(id);
-  }
-
-  return inst;
-}
-
-AssertAssignableInstr* FlowGraphDeserializer::DeserializeAssertAssignable(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  auto const val = ParseValue(Retrieve(sexp, 1));
-  if (val == nullptr) return nullptr;
-
-  auto const dst_type = ParseValue(Retrieve(sexp, 2));
-  if (dst_type == nullptr) return nullptr;
-
-  auto const inst_type_args = ParseValue(Retrieve(sexp, 3));
-  if (inst_type_args == nullptr) return nullptr;
-
-  auto const func_type_args = ParseValue(Retrieve(sexp, 4));
-  if (func_type_args == nullptr) return nullptr;
-
-  auto& dst_name = String::ZoneHandle(zone());
-  auto const dst_name_sexp = Retrieve(sexp, "name");
-  if (!ParseDartValue(dst_name_sexp, &dst_name)) return nullptr;
-
-  auto kind = AssertAssignableInstr::Kind::kUnknown;
-  if (auto const kind_sexp = CheckSymbol(sexp->ExtraLookupValue("kind"))) {
-    if (!AssertAssignableInstr::ParseKind(kind_sexp->value(), &kind)) {
-      StoreError(kind_sexp, "unknown AssertAssignable kind");
-      return nullptr;
-    }
-  }
-
-  return new (zone())
-      AssertAssignableInstr(info.source, val, dst_type, inst_type_args,
-                            func_type_args, dst_name, info.deopt_id, kind);
-}
-
-AssertBooleanInstr* FlowGraphDeserializer::DeserializeAssertBoolean(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  auto const val = ParseValue(Retrieve(sexp, 1));
-  if (val == nullptr) return nullptr;
-
-  return new (zone()) AssertBooleanInstr(info.source, val, info.deopt_id);
-}
-
-BooleanNegateInstr* FlowGraphDeserializer::DeserializeBooleanNegate(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  auto const value = ParseValue(Retrieve(sexp, 1));
-  if (value == nullptr) return nullptr;
-
-  return new (zone()) BooleanNegateInstr(value);
-}
-
-BranchInstr* FlowGraphDeserializer::DeserializeBranch(SExpList* sexp,
-                                                      const InstrInfo& info) {
-  auto const comp_sexp = CheckTaggedList(Retrieve(sexp, 1));
-  auto const comp_inst = ParseInstruction(comp_sexp);
-  if (comp_inst == nullptr) return nullptr;
-  if (!comp_inst->IsComparison()) {
-    StoreError(sexp->At(1), "expected comparison instruction");
-    return nullptr;
-  }
-  auto const comparison = comp_inst->AsComparison();
-
-  auto const true_block = FetchBlock(CheckSymbol(Retrieve(sexp, 2)));
-  if (true_block == nullptr) return nullptr;
-  if (!true_block->IsTargetEntry()) {
-    StoreError(sexp->At(2), "true successor is not a target block");
-    return nullptr;
-  }
-
-  auto const false_block = FetchBlock(CheckSymbol(Retrieve(sexp, 3)));
-  if (false_block == nullptr) return nullptr;
-  if (!false_block->IsTargetEntry()) {
-    StoreError(sexp->At(3), "false successor is not a target block");
-    return nullptr;
-  }
-
-  auto const branch = new (zone()) BranchInstr(comparison, info.deopt_id);
-  *branch->true_successor_address() = true_block->AsTargetEntry();
-  *branch->false_successor_address() = false_block->AsTargetEntry();
-  return branch;
-}
-
-CheckNullInstr* FlowGraphDeserializer::DeserializeCheckNull(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  auto const val = ParseValue(Retrieve(sexp, 1));
-  if (val == nullptr) return nullptr;
-
-  auto& func_name = String::ZoneHandle(zone());
-  if (auto const name_sexp =
-          CheckString(sexp->ExtraLookupValue("function_name"))) {
-    func_name = String::New(name_sexp->value(), Heap::kOld);
-  }
-
-  return new (zone())
-      CheckNullInstr(val, func_name, info.deopt_id, info.source);
-}
-
-CheckStackOverflowInstr* FlowGraphDeserializer::DeserializeCheckStackOverflow(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  intptr_t stack_depth = 0;
-  if (auto const stack_sexp =
-          CheckInteger(sexp->ExtraLookupValue("stack_depth"))) {
-    stack_depth = stack_sexp->value();
-  }
-
-  intptr_t loop_depth = 0;
-  if (auto const loop_sexp =
-          CheckInteger(sexp->ExtraLookupValue("loop_depth"))) {
-    loop_depth = loop_sexp->value();
-  }
-
-  auto kind = CheckStackOverflowInstr::kOsrAndPreemption;
-  if (auto const kind_sexp = CheckSymbol(sexp->ExtraLookupValue("kind"))) {
-    ASSERT(kind_sexp->Equals("OsrOnly"));
-    kind = CheckStackOverflowInstr::kOsrOnly;
-  }
-
-  return new (zone()) CheckStackOverflowInstr(info.source, stack_depth,
-                                              loop_depth, info.deopt_id, kind);
-}
-
-ConstantInstr* FlowGraphDeserializer::DeserializeConstant(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  Object& obj = Object::ZoneHandle(zone());
-  if (!ParseDartValue(Retrieve(sexp, 1), &obj)) return nullptr;
-  return new (zone()) ConstantInstr(obj, info.source);
-}
-
-DebugStepCheckInstr* FlowGraphDeserializer::DeserializeDebugStepCheck(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  auto kind = UntaggedPcDescriptors::kAnyKind;
-  if (auto const kind_sexp = CheckSymbol(Retrieve(sexp, "stub_kind"))) {
-    if (!UntaggedPcDescriptors::ParseKind(kind_sexp->value(), &kind)) {
-      StoreError(kind_sexp, "not a valid UntaggedPcDescriptors::Kind name");
-      return nullptr;
-    }
-  }
-  return new (zone()) DebugStepCheckInstr(info.source, kind, info.deopt_id);
-}
-
-GotoInstr* FlowGraphDeserializer::DeserializeGoto(SExpList* sexp,
-                                                  const InstrInfo& info) {
-  auto const block = FetchBlock(CheckSymbol(Retrieve(sexp, 1)));
-  if (block == nullptr) return nullptr;
-  if (!block->IsJoinEntry()) {
-    StoreError(sexp->At(1), "target of goto must be join entry");
-    return nullptr;
-  }
-  return new (zone()) GotoInstr(block->AsJoinEntry(), info.deopt_id);
-}
-
-InstanceCallInstr* FlowGraphDeserializer::DeserializeInstanceCall(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  auto& interface_target = Function::ZoneHandle(zone());
-  auto& tearoff_interface_target = Function::ZoneHandle(zone());
-  if (!ParseDartValue(Retrieve(sexp, "interface_target"), &interface_target)) {
-    return nullptr;
-  }
-  if (!ParseDartValue(Retrieve(sexp, "tearoff_interface_target"),
-                      &tearoff_interface_target)) {
-    return nullptr;
-  }
-  auto& function_name = String::ZoneHandle(zone());
-  // If we have an explicit function_name value, then use that value. Otherwise,
-  // if we have an non-null interface_target, use its name.
-  if (auto const name_sexp = sexp->ExtraLookupValue("function_name")) {
-    if (!ParseDartValue(name_sexp, &function_name)) return nullptr;
-  } else if (!interface_target.IsNull()) {
-    function_name = interface_target.name();
-  } else if (!tearoff_interface_target.IsNull()) {
-    function_name = tearoff_interface_target.name();
-  }
-
-  auto token_kind = Token::Kind::kILLEGAL;
-  if (auto const kind_sexp =
-          CheckSymbol(sexp->ExtraLookupValue("token_kind"))) {
-    if (!Token::FromStr(kind_sexp->value(), &token_kind)) {
-      StoreError(kind_sexp, "unexpected token kind");
-      return nullptr;
-    }
-  }
-
-  CallInfo call_info(zone());
-  if (!ParseCallInfo(sexp, &call_info)) return nullptr;
-
-  intptr_t checked_arg_count = 0;
-  if (auto const checked_sexp =
-          CheckInteger(sexp->ExtraLookupValue("checked_arg_count"))) {
-    checked_arg_count = checked_sexp->value();
-  }
-
-  auto const inst = new (zone()) InstanceCallInstr(
-      info.source, function_name, token_kind, call_info.inputs,
-      call_info.type_args_len, call_info.argument_names, checked_arg_count,
-      info.deopt_id, interface_target, tearoff_interface_target);
-
-  if (call_info.result_type != nullptr) {
-    inst->SetResultType(zone(), *call_info.result_type);
-  }
-
-  inst->set_entry_kind(call_info.entry_kind);
-
-  if (auto const ic_data_sexp =
-          CheckTaggedList(Retrieve(sexp, "ic_data"), "ICData")) {
-    if (!CreateICData(ic_data_sexp, inst)) return nullptr;
-  }
-
-  return inst;
-}
-
-LoadClassIdInstr* FlowGraphDeserializer::DeserializeLoadClassId(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  auto const val = ParseValue(Retrieve(sexp, 1));
-  if (val == nullptr) return nullptr;
-
-  return new (zone()) LoadClassIdInstr(val);
-}
-
-LoadFieldInstr* FlowGraphDeserializer::DeserializeLoadField(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  auto const instance = ParseValue(Retrieve(sexp, 1));
-  if (instance == nullptr) return nullptr;
-
-  const Slot* slot;
-  if (!ParseSlot(CheckTaggedList(Retrieve(sexp, 2)), &slot)) return nullptr;
-
-  bool calls_initializer = false;
-  if (auto const calls_initializer_sexp =
-          CheckBool(sexp->ExtraLookupValue("calls_initializer"))) {
-    calls_initializer = calls_initializer_sexp->value();
-  }
-
-  return new (zone()) LoadFieldInstr(instance, *slot, info.source,
-                                     calls_initializer, info.deopt_id);
-}
-
-NativeCallInstr* FlowGraphDeserializer::DeserializeNativeCall(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  auto& function = Function::ZoneHandle(zone());
-  if (!ParseDartValue(Retrieve(sexp, "function"), &function)) return nullptr;
-  if (!function.IsFunction()) {
-    StoreError(sexp->At(1), "expected a Function value");
-    return nullptr;
-  }
-
-  auto const name_sexp = CheckString(Retrieve(sexp, "name"));
-  if (name_sexp == nullptr) return nullptr;
-  const auto& name =
-      String::ZoneHandle(zone(), String::New(name_sexp->value()));
-
-  bool link_lazily = false;
-  if (auto const link_sexp = CheckBool(sexp->ExtraLookupValue("link_lazily"))) {
-    link_lazily = link_sexp->value();
-  }
-
-  CallInfo call_info(zone());
-  if (!ParseCallInfo(sexp, &call_info)) return nullptr;
-
-  return new (zone()) NativeCallInstr(&name, &function, link_lazily,
-                                      info.source, call_info.inputs);
-}
-
-ParameterInstr* FlowGraphDeserializer::DeserializeParameter(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  ASSERT(current_block_ != nullptr);
-  if (auto const index_sexp = CheckInteger(Retrieve(sexp, 1))) {
-    const auto param_offset_sexp =
-        CheckInteger(sexp->ExtraLookupValue("param_offset"));
-    ASSERT(param_offset_sexp != nullptr);
-    const auto representation_sexp =
-        CheckSymbol(sexp->ExtraLookupValue("representation"));
-    Representation representation;
-    if (!Location::ParseRepresentation(representation_sexp->value(),
-                                       &representation)) {
-      StoreError(representation_sexp, "unknown parameter representation");
-    }
-    return new (zone())
-        ParameterInstr(index_sexp->value(), param_offset_sexp->value(),
-                       current_block_, representation);
-  }
-  return nullptr;
-}
-
-ReturnInstr* FlowGraphDeserializer::DeserializeReturn(SExpList* list,
-                                                      const InstrInfo& info) {
-  Value* val = ParseValue(Retrieve(list, 1));
-  if (val == nullptr) return nullptr;
-  return new (zone()) ReturnInstr(info.source, val, info.deopt_id);
-}
-
-SpecialParameterInstr* FlowGraphDeserializer::DeserializeSpecialParameter(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  ASSERT(current_block_ != nullptr);
-  auto const kind_sexp = CheckSymbol(Retrieve(sexp, 1));
-  if (kind_sexp == nullptr) return nullptr;
-  SpecialParameterInstr::SpecialParameterKind kind;
-  if (!SpecialParameterInstr::ParseKind(kind_sexp->value(), &kind)) {
-    StoreError(kind_sexp, "unknown special parameter kind");
-    return nullptr;
-  }
-  return new (zone())
-      SpecialParameterInstr(kind, info.deopt_id, current_block_);
-}
-
-StaticCallInstr* FlowGraphDeserializer::DeserializeStaticCall(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  auto& function = Function::ZoneHandle(zone());
-  auto const function_sexp =
-      CheckTaggedList(Retrieve(sexp, "function"), "Function");
-  if (!ParseFunction(function_sexp, &function)) return nullptr;
-
-  CallInfo call_info(zone());
-  if (!ParseCallInfo(sexp, &call_info)) return nullptr;
-
-  intptr_t call_count = 0;
-  if (auto const call_count_sexp =
-          CheckInteger(sexp->ExtraLookupValue("call_count"))) {
-    call_count = call_count_sexp->value();
-  }
-
-  auto rebind_rule = ICData::kStatic;
-  if (auto const rebind_sexp =
-          CheckSymbol(sexp->ExtraLookupValue("rebind_rule"))) {
-    if (!ICData::ParseRebindRule(rebind_sexp->value(), &rebind_rule)) {
-      StoreError(rebind_sexp, "unknown rebind rule value");
-      return nullptr;
-    }
-  }
-
-  auto const inst = new (zone()) StaticCallInstr(
-      info.source, function, call_info.type_args_len, call_info.argument_names,
-      call_info.inputs, info.deopt_id, call_count, rebind_rule);
-
-  if (call_info.result_type != nullptr) {
-    inst->SetResultType(zone(), *call_info.result_type);
-  }
-
-  inst->set_entry_kind(call_info.entry_kind);
-
-  if (auto const ic_data_sexp =
-          CheckTaggedList(sexp->ExtraLookupValue("ic_data"), "ICData")) {
-    if (!CreateICData(ic_data_sexp, inst)) return nullptr;
-  }
-
-  return inst;
-}
-
-StoreInstanceFieldInstr* FlowGraphDeserializer::DeserializeStoreInstanceField(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  auto const instance = ParseValue(Retrieve(sexp, 1));
-  if (instance == nullptr) return nullptr;
-
-  const Slot* slot = nullptr;
-  if (!ParseSlot(CheckTaggedList(Retrieve(sexp, 2), "Slot"), &slot)) {
-    return nullptr;
-  }
-
-  auto const value = ParseValue(Retrieve(sexp, 3));
-  if (value == nullptr) return nullptr;
-
-  auto barrier_type = kNoStoreBarrier;
-  if (auto const bar_sexp = CheckBool(sexp->ExtraLookupValue("emit_barrier"))) {
-    if (bar_sexp->value()) barrier_type = kEmitStoreBarrier;
-  }
-
-  auto kind = StoreInstanceFieldInstr::Kind::kOther;
-  if (auto const init_sexp = CheckBool(sexp->ExtraLookupValue("is_init"))) {
-    if (init_sexp->value()) kind = StoreInstanceFieldInstr::Kind::kInitializing;
-  }
-
-  return new (zone()) StoreInstanceFieldInstr(*slot, instance, value,
-                                              barrier_type, info.source, kind);
-}
-
-StrictCompareInstr* FlowGraphDeserializer::DeserializeStrictCompare(
-    SExpList* sexp,
-    const InstrInfo& info) {
-  auto const token_sexp = CheckSymbol(Retrieve(sexp, 1));
-  if (token_sexp == nullptr) return nullptr;
-  Token::Kind kind;
-  if (!Token::FromStr(token_sexp->value(), &kind)) return nullptr;
-
-  auto const left = ParseValue(Retrieve(sexp, 2));
-  if (left == nullptr) return nullptr;
-
-  auto const right = ParseValue(Retrieve(sexp, 3));
-  if (right == nullptr) return nullptr;
-
-  bool needs_check = false;
-  if (auto const check_sexp = CheckBool(Retrieve(sexp, "needs_check"))) {
-    needs_check = check_sexp->value();
-  }
-
-  return new (zone()) StrictCompareInstr(info.source, kind, left, right,
-                                         needs_check, info.deopt_id);
-}
-
-ThrowInstr* FlowGraphDeserializer::DeserializeThrow(SExpList* sexp,
-                                                    const InstrInfo& info) {
-  Value* exception = ParseValue(Retrieve(sexp, 1));
-  if (exception == nullptr) return nullptr;
-  return new (zone()) ThrowInstr(info.source, info.deopt_id, exception);
-}
-
-bool FlowGraphDeserializer::ParseCallInfo(SExpList* call,
-                                          CallInfo* out,
-                                          intptr_t num_extra_inputs) {
-  ASSERT(out != nullptr);
-
-  if (auto const len_sexp =
-          CheckInteger(call->ExtraLookupValue("type_args_len"))) {
-    out->type_args_len = len_sexp->value();
-  }
-
-  if (auto const arg_names_sexp =
-          CheckList(call->ExtraLookupValue("arg_names"))) {
-    out->argument_names = Array::New(arg_names_sexp->Length(), Heap::kOld);
-    for (intptr_t i = 0, n = arg_names_sexp->Length(); i < n; i++) {
-      auto name_sexp = CheckString(Retrieve(arg_names_sexp, i));
-      if (name_sexp == nullptr) return false;
-      tmp_string_ = String::New(name_sexp->value(), Heap::kOld);
-      out->argument_names.SetAt(i, tmp_string_);
-    }
-  }
-
-  if (auto const args_len_sexp =
-          CheckInteger(call->ExtraLookupValue("args_len"))) {
-    out->args_len = args_len_sexp->value();
-  }
-
-  if (auto const result_sexp = CheckTaggedList(
-          call->ExtraLookupValue("result_type"), "CompileType")) {
-    out->result_type = ParseCompileType(result_sexp);
-  }
-
-  if (auto const kind_sexp =
-          CheckSymbol(call->ExtraLookupValue("entry_kind"))) {
-    if (!Code::ParseEntryKind(kind_sexp->value(), &out->entry_kind))
-      return false;
-  }
-
-  // Type arguments are wrapped in a TypeArguments array, so no matter how
-  // many there are, they are contained in a single pushed argument.
-  auto const all_args_len = (out->type_args_len > 0 ? 1 : 0) + out->args_len;
-
-  const intptr_t num_inputs = all_args_len + num_extra_inputs;
-  out->inputs = new (zone()) InputsArray(zone(), num_inputs);
-  for (intptr_t i = 0; i < num_inputs; ++i) {
-    auto const input = ParseValue(Retrieve(call, 1 + i));
-    if (input == nullptr) return false;
-    out->inputs->Add(input);
-  }
-
-  return true;
-}
-
-Value* FlowGraphDeserializer::ParseValue(SExpression* sexp,
-                                         bool allow_pending) {
-  CompileType* type = nullptr;
-  bool inherit_type = false;
-  auto name = sexp->AsSymbol();
-  if (name == nullptr) {
-    auto const list = CheckTaggedList(sexp, "value");
-    name = CheckSymbol(Retrieve(list, 1));
-    if (auto const type_sexp =
-            CheckTaggedList(list->ExtraLookupValue("type"), "CompileType")) {
-      type = ParseCompileType(type_sexp);
-      if (type == nullptr) return nullptr;
-    } else if (auto const inherit_sexp =
-                   CheckBool(list->ExtraLookupValue("inherit_type"))) {
-      inherit_type = inherit_sexp->value();
-    } else {
-      // We assume that the type should be inherited from the definition for
-      // for (value ...) forms without an explicit type.
-      inherit_type = true;
-    }
-  }
-  intptr_t index;
-  if (!ParseUse(name, &index)) return nullptr;
-  auto const def = definition_map_.LookupValue(index);
-  Value* val;
-  if (def == nullptr) {
-    if (!allow_pending) {
-      StoreError(sexp, "found use prior to definition");
-      return nullptr;
-    }
-    val = AddNewPendingValue(sexp, index, inherit_type);
-  } else {
-    val = new (zone()) Value(def);
-    if (inherit_type) {
-      if (def->HasType()) {
-        val->reaching_type_ = def->Type();
-      } else {
-        StoreError(sexp, "value inherits type, but no type found");
-        return nullptr;
-      }
-    }
-  }
-  if (type != nullptr) val->SetReachingType(type);
-  return val;
-}
-
-CompileType* FlowGraphDeserializer::ParseCompileType(SExpList* sexp) {
-  // TODO(sstrickl): Currently we only print out nullable if it's false
-  // (or during verbose printing). Switch this when NNBD is the standard.
-  bool nullable = CompileType::kNullable;
-  if (auto const nullable_sexp =
-          CheckBool(sexp->ExtraLookupValue("nullable"))) {
-    nullable = nullable_sexp->value() ? CompileType::kNullable
-                                      : CompileType::kNonNullable;
-  }
-
-  intptr_t cid = kIllegalCid;
-  if (auto const cid_sexp = CheckInteger(sexp->ExtraLookupValue("cid"))) {
-    // TODO(sstrickl): Check that the cid is a valid concrete cid, or a cid
-    // otherwise found in CompileTypes like kIllegalCid or kDynamicCid.
-    cid = cid_sexp->value();
-  }
-
-  AbstractType* type = nullptr;
-  if (auto const type_sexp = sexp->ExtraLookupValue("type")) {
-    auto& type_handle = AbstractType::ZoneHandle(zone());
-    if (!ParseAbstractType(type_sexp, &type_handle)) return nullptr;
-    type = &type_handle;
-  }
-  return new (zone()) CompileType(nullable, cid, type);
-}
-
-Environment* FlowGraphDeserializer::ParseEnvironment(SExpList* list) {
-  if (list == nullptr) return nullptr;
-  intptr_t fixed_param_count = 0;
-  if (auto const fpc_sexp =
-          CheckInteger(list->ExtraLookupValue("fixed_param_count"))) {
-    fixed_param_count = fpc_sexp->value();
-  }
-  Environment* outer_env = nullptr;
-  if (auto const outer_sexp = CheckList(list->ExtraLookupValue("outer"))) {
-    outer_env = ParseEnvironment(outer_sexp);
-    if (outer_env == nullptr) return nullptr;
-    if (auto const deopt_sexp =
-            CheckInteger(outer_sexp->ExtraLookupValue("deopt_id"))) {
-      outer_env->deopt_id_ = deopt_sexp->value();
-    }
-  }
-
-  ASSERT(parsed_function_ != nullptr);
-  auto const env = new (zone()) Environment(list->Length(), fixed_param_count,
-                                            *parsed_function_, outer_env);
-
-  for (intptr_t i = 0; i < list->Length(); i++) {
-    auto const elem_sexp = Retrieve(list, i);
-    if (elem_sexp == nullptr) return nullptr;
-    auto val = ParseValue(elem_sexp, /*allow_pending=*/false);
-    if (val == nullptr) return nullptr;
-    env->PushValue(val);
-  }
-
-  return env;
-}
-
-bool FlowGraphDeserializer::ParseDartValue(SExpression* sexp, Object* out) {
-  ASSERT(out != nullptr);
-  if (sexp == nullptr) return false;
-  *out = Object::null();
-
-  if (auto const sym = sexp->AsSymbol()) {
-    // We'll use the null value in *out as a marker later, so go ahead and exit
-    // early if we parse one.
-    if (sym->Equals("null")) return true;
-    if (sym->Equals("sentinel")) {
-      *out = Object::sentinel().ptr();
-      return true;
-    }
-
-    // The only other symbols that should appear in Dart value position are
-    // names of constant definitions.
-    auto const val = ParseValue(sym, /*allow_pending=*/false);
-    if (val == nullptr) return false;
-    if (!val->BindsToConstant()) {
-      StoreError(sym, "not a reference to a constant definition");
-      return false;
-    }
-    *out = val->BoundConstant().ptr();
-    // Values used in constant definitions have already been canonicalized,
-    // so just exit.
-    return true;
-  }
-
-  // Other instance values may need to be canonicalized, so do that before
-  // returning.
-  if (auto const b = sexp->AsBool()) {
-    *out = Bool::Get(b->value()).ptr();
-  } else if (auto const str = sexp->AsString()) {
-    *out = String::New(str->value(), Heap::kOld);
-  } else if (auto const i = sexp->AsInteger()) {
-    *out = Integer::New(i->value(), Heap::kOld);
-  } else if (auto const d = sexp->AsDouble()) {
-    *out = Double::New(d->value(), Heap::kOld);
-  } else if (auto const list = CheckTaggedList(sexp)) {
-    auto const tag = list->Tag();
-    if (tag->Equals("Class")) {
-      return ParseClass(list, out);
-    } else if (tag->Equals("Type")) {
-      return ParseType(list, out);
-    } else if (tag->Equals("TypeArguments")) {
-      return ParseTypeArguments(list, out);
-    } else if (tag->Equals("Field")) {
-      return ParseField(list, out);
-    } else if (tag->Equals("Function")) {
-      return ParseFunction(list, out);
-    } else if (tag->Equals("FunctionType")) {
-      return ParseFunctionType(list, out);
-    } else if (tag->Equals("TypeParameter")) {
-      return ParseTypeParameter(list, out);
-    } else if (tag->Equals("Array")) {
-      return ParseArray(list, out);
-    } else if (tag->Equals("ImmutableList")) {
-      return ParseImmutableList(list, out);
-    } else if (tag->Equals("Instance")) {
-      return ParseInstance(list, out);
-    } else if (tag->Equals("Closure")) {
-      return ParseClosure(list, out);
-    } else if (tag->Equals("TypeRef")) {
-      return ParseTypeRef(list, out);
-    }
-  }
-
-  // If we're here and still haven't gotten a non-null value, then something
-  // went wrong. (Likely an unrecognized value.)
-  if (out->IsNull()) {
-    StoreError(sexp, "unhandled Dart value");
-    return false;
-  }
-
-  if (!out->IsInstance()) return true;
-  return CanonicalizeInstance(sexp, out);
-}
-
-bool FlowGraphDeserializer::CanonicalizeInstance(SExpression* sexp,
-                                                 Object* out) {
-  ASSERT(out != nullptr);
-  if (!out->IsInstance()) return true;
-  // Instance::Canonicalize uses the current zone for the passed in thread,
-  // not an explicitly provided zone. This means we cannot be run in a context
-  // where [thread()->zone()] does not match [zone()] (e.g., due to StackZone)
-  // until this is addressed.
-  *out = Instance::Cast(*out).Canonicalize(thread());
-  return true;
-}
-
-bool FlowGraphDeserializer::ParseAbstractType(SExpression* sexp, Object* out) {
-  ASSERT(out != nullptr);
-  if (sexp == nullptr) return false;
-
-  // If it's a symbol, it should be a reference to a constant definition, which
-  // is handled in ParseType.
-  if (auto const sym = sexp->AsSymbol()) {
-    return ParseType(sexp, out);
-  } else if (auto const list = CheckTaggedList(sexp)) {
-    auto const tag = list->Tag();
-    if (tag->Equals("Type")) {
-      return ParseType(list, out);
-    } else if (tag->Equals("TypeParameter")) {
-      return ParseTypeParameter(list, out);
-    } else if (tag->Equals("TypeRef")) {
-      return ParseTypeRef(list, out);
-    }
-  }
-
-  StoreError(sexp, "not an AbstractType");
-  return false;
-}
-
-bool FlowGraphDeserializer::ParseClass(SExpList* list, Object* out) {
-  ASSERT(out != nullptr);
-  if (list == nullptr) return false;
-
-  auto const ref_sexp = Retrieve(list, 1);
-  if (ref_sexp == nullptr) return false;
-  if (auto const cid_sexp = ref_sexp->AsInteger()) {
-    ClassTable* table = thread()->isolate_group()->class_table();
-    if (!table->HasValidClassAt(cid_sexp->value())) {
-      StoreError(cid_sexp, "no valid class found for cid");
-      return false;
-    }
-    *out = table->At(cid_sexp->value());
-  } else if (auto const name_sexp = ref_sexp->AsSymbol()) {
-    if (!ParseCanonicalName(name_sexp, out)) return false;
-    if (!out->IsClass()) {
-      StoreError(name_sexp, "expected the name of a class");
-      return false;
-    }
-  }
-  return true;
-}
-
-bool FlowGraphDeserializer::ParseClosure(SExpList* list, Object* out) {
-  ASSERT(out != nullptr);
-  if (list == nullptr) return false;
-
-  auto& function = Function::ZoneHandle(zone());
-  auto const function_sexp = CheckTaggedList(Retrieve(list, 1), "Function");
-  if (!ParseFunction(function_sexp, &function)) return false;
-
-  auto& context = Context::ZoneHandle(zone());
-  if (list->ExtraLookupValue("context") != nullptr) {
-    StoreError(list, "closures with contexts currently unhandled");
-    return false;
-  }
-
-  auto& inst_type_args = TypeArguments::ZoneHandle(zone());
-  if (auto const type_args_sexp = Retrieve(list, "inst_type_args")) {
-    if (!ParseTypeArguments(type_args_sexp, &inst_type_args)) return false;
-  }
-
-  auto& func_type_args = TypeArguments::ZoneHandle(zone());
-  if (auto const type_args_sexp = Retrieve(list, "func_type_args")) {
-    if (!ParseTypeArguments(type_args_sexp, &func_type_args)) return false;
-  }
-
-  auto& delayed_type_args = TypeArguments::ZoneHandle(zone());
-  if (auto const type_args_sexp = Retrieve(list, "delayed_type_args")) {
-    if (!ParseTypeArguments(type_args_sexp, &delayed_type_args)) {
-      return false;
-    }
-  }
-
-  *out = Closure::New(inst_type_args, func_type_args, delayed_type_args,
-                      function, context, Heap::kOld);
-  return CanonicalizeInstance(list, out);
-}
-
-bool FlowGraphDeserializer::ParseField(SExpList* list, Object* out) {
-  auto const name_sexp = CheckSymbol(Retrieve(list, 1));
-  if (!ParseCanonicalName(name_sexp, out)) return false;
-  if (!out->IsField()) {
-    StoreError(list, "expected a Field name");
-    return false;
-  }
-  return true;
-}
-
-bool FlowGraphDeserializer::ParseFunction(SExpList* list, Object* out) {
-  ASSERT(out != nullptr);
-  if (list == nullptr) return false;
-
-  auto const name_sexp = CheckSymbol(Retrieve(list, 1));
-  if (!ParseCanonicalName(name_sexp, out)) return false;
-  if (!out->IsFunction()) {
-    StoreError(list, "expected a Function name");
-    return false;
-  }
-  auto& function = Function::Cast(*out);
-  // Check the kind expected by the S-expression if one was specified.
-  if (auto const kind_sexp = CheckSymbol(list->ExtraLookupValue("kind"))) {
-    UntaggedFunction::Kind kind;
-    if (!UntaggedFunction::ParseKind(kind_sexp->value(), &kind)) {
-      StoreError(kind_sexp, "unexpected function kind");
-      return false;
-    }
-    if (function.kind() != kind) {
-      auto const kind_str = UntaggedFunction::KindToCString(function.kind());
-      StoreError(list, "retrieved function has kind %s", kind_str);
-      return false;
-    }
-  }
-  return true;
-}
-
-bool FlowGraphDeserializer::ParseFunctionType(SExpList* list, Object* out) {
-  ASSERT(out != nullptr);
-  if (list == nullptr) return false;
-  auto& type_params = TypeArguments::ZoneHandle(zone());
-  if (auto const type_params_sexp = Retrieve(list, "type_params")) {
-    if (!ParseTypeArguments(type_params_sexp, &type_params)) return false;
-  }
-  auto& result_type = AbstractType::ZoneHandle(zone());
-  if (auto const result_type_sexp = Retrieve(list, "result_type")) {
-    if (!ParseAbstractType(result_type_sexp, &result_type)) return false;
-  }
-  auto& parameter_types = Array::ZoneHandle(zone());
-  if (auto const parameter_types_sexp = Retrieve(list, "parameter_types")) {
-    if (!ParseDartValue(parameter_types_sexp, &parameter_types)) return false;
-  }
-  auto& parameter_names = Array::ZoneHandle(zone());
-  if (auto const parameter_names_sexp = Retrieve(list, "parameter_names")) {
-    if (!ParseDartValue(parameter_names_sexp, &parameter_names)) return false;
-  }
-  intptr_t packed_fields;
-  if (auto const packed_fields_sexp =
-          CheckInteger(list->ExtraLookupValue("packed_fields"))) {
-    packed_fields = packed_fields_sexp->value();
-  } else {
-    return false;
-  }
-  auto& sig = FunctionType::ZoneHandle(zone(), FunctionType::New());
-  sig.set_type_parameters(type_params);
-  sig.set_result_type(result_type);
-  sig.set_parameter_types(parameter_types);
-  sig.set_parameter_names(parameter_names);
-  sig.set_packed_fields(packed_fields);
-  *out = sig.ptr();
-  return true;
-}
-
-bool FlowGraphDeserializer::ParseArray(SExpList* list, Object* out) {
-  ASSERT(out != nullptr);
-  if (list == nullptr) return false;
-
-  *out = Array::New(list->Length() - 1, Heap::kOld);
-  auto& arr = Array::Cast(*out);
-  // Arrays may contain other arrays, so we'll need a new handle in which to
-  // store elements.
-  auto& elem = Object::Handle(zone());
-  for (intptr_t i = 1; i < list->Length(); i++) {
-    if (!ParseDartValue(Retrieve(list, i), &elem)) return false;
-    arr.SetAt(i - 1, elem);
-  }
-  if (auto type_args_sexp = list->ExtraLookupValue("type_args")) {
-    if (!ParseTypeArguments(type_args_sexp, &array_type_args_)) return false;
-    arr.SetTypeArguments(array_type_args_);
-  }
-  return true;
-}
-
-bool FlowGraphDeserializer::ParseImmutableList(SExpList* list, Object* out) {
-  if (!ParseArray(list, out)) return false;
-
-  Array::Cast(*out).MakeImmutable();
-  return CanonicalizeInstance(list, out);
-}
-
-bool FlowGraphDeserializer::ParseInstance(SExpList* list, Object* out) {
-  ASSERT(out != nullptr);
-  if (list == nullptr) return false;
-  auto const cid_sexp = CheckInteger(Retrieve(list, 1));
-  if (cid_sexp == nullptr) return false;
-
-  auto const table = thread()->isolate_group()->class_table();
-  if (!table->HasValidClassAt(cid_sexp->value())) {
-    StoreError(cid_sexp, "cid is not valid");
-    return false;
-  }
-
-  ASSERT(cid_sexp->value() != kNullCid);  // Must use canonical instances.
-  ASSERT(cid_sexp->value() != kBoolCid);  // Must use canonical instances.
-  instance_class_ = table->At(cid_sexp->value());
-  *out = Instance::New(instance_class_, Heap::kOld);
-  auto& instance = Instance::Cast(*out);
-
-  if (auto const type_args = list->ExtraLookupValue("type_args")) {
-    instance_type_args_ = TypeArguments::null();
-    if (!ParseTypeArguments(type_args, &instance_type_args_)) return false;
-    if (!instance_class_.IsGeneric()) {
-      StoreError(list,
-                 "type arguments provided for an instance of a "
-                 "non-generic class");
-      return false;
-    }
-    instance.SetTypeArguments(instance_type_args_);
-  }
-
-  // Pick out and store the final instance fields of the class, as values must
-  // be provided for them. Error if there are any non-final instance fields.
-  instance_fields_array_ = instance_class_.fields();
-  auto const field_count = instance_fields_array_.Length();
-  GrowableArray<const Field*> final_fields(zone(), field_count);
-  for (intptr_t i = 0, n = field_count; i < n; i++) {
-    instance_field_ = Field::RawCast(instance_fields_array_.At(i));
-    if (!instance_field_.is_instance()) continue;
-    if (!instance_field_.is_final()) {
-      StoreError(list, "class for instance has non-final instance fields");
-      return false;
-    }
-    auto& fresh_handle = Field::Handle(zone(), instance_field_.ptr());
-    final_fields.Add(&fresh_handle);
-  }
-
-  // If there is no (Fields...) sub-expression or it has no extra info, then
-  // ensure there are no final fields before returning the canonicalized form.
-  SExpList* fields_sexp = nullptr;
-  bool fields_provided = list->Length() > 2;
-  if (fields_provided) {
-    fields_sexp = CheckTaggedList(Retrieve(list, 2), "Fields");
-    if (fields_sexp == nullptr) return false;
-    fields_provided = fields_sexp->ExtraLength() != 0;
-  }
-  if (!fields_provided) {
-    if (!final_fields.is_empty()) {
-      StoreError(list, "values not provided for final fields of instance");
-      return false;
-    }
-    return CanonicalizeInstance(list, out);
-  }
-
-  // At this point, we have final instance field values to set on the new
-  // instance before canonicalization. When setting instance fields, we may
-  // cause field guards to be invalidated. Because of this, we must either be
-  // running on the mutator thread or be at a safepoint when calling `SetField`.
-  //
-  // For IR round-trips, the constants we create have already existed before in
-  // the VM heap, which means field invalidation cannot occur. Thus, we create a
-  // closure that sets the fields of the instance and then conditionally run
-  // that closure at a safepoint if not in the mutator thread.
-  //
-  // TODO(dartbug.com/36882): When deserializing IR that was not generated
-  // during the RoundTripSerialization pass, we are no longer guaranteed that
-  // deserialization of instances will not invalidate field guards. Thus, we may
-  // need to support invalidating field guards on non-mutator threads or fall
-  // back onto forcing the deserialization to happen on the mutator thread.
-  auto set_instance_fields = [&]() {
-    auto& inst = Instance::Cast(*out);
-    // We'll need to allocate a handle for the parsed value as we may have
-    // instances as field values and so this function may be re-entered.
-    auto& value = Object::Handle(zone());
-    for (auto field : final_fields) {
-      tmp_string_ = field->UserVisibleName();
-      auto const name = tmp_string_.ToCString();
-      auto const value_sexp = Retrieve(fields_sexp, name);
-      if (value_sexp == nullptr) {
-        StoreError(list, "no value provided for final instance field %s", name);
-        return false;
-      }
-      if (!ParseDartValue(value_sexp, &value)) return false;
-      inst.SetField(*field, value);
-    }
-    return true;
-  };
-
-  auto const t = Thread::Current();
-  if (!t->IsMutatorThread()) {
-    SafepointOperationScope safepoint_scope(t);
-    if (!set_instance_fields()) return false;
-  } else {
-    if (!set_instance_fields()) return false;
-  }
-
-  return CanonicalizeInstance(list, out);
-}
-
-bool FlowGraphDeserializer::ParseType(SExpression* sexp, Object* out) {
-  ASSERT(out != nullptr);
-  if (sexp == nullptr) return false;
-
-  if (auto const sym = sexp->AsSymbol()) {
-    auto const val = ParseValue(sexp, /*allow_pending=*/false);
-    if (val == nullptr) {
-      StoreError(sexp, "expected type or reference to constant definition");
-      return false;
-    }
-    if (!val->BindsToConstant()) {
-      StoreError(sexp, "reference to non-constant definition");
-      return false;
-    }
-    *out = val->BoundConstant().ptr();
-    if (!out->IsType()) {
-      StoreError(sexp, "expected Type constant");
-      return false;
-    }
-    return true;
-  }
-  auto const list = CheckTaggedList(sexp, "Type");
-  if (list == nullptr) return false;
-
-  const auto hash_sexp = CheckInteger(list->ExtraLookupValue("hash"));
-  const auto is_recursive = hash_sexp != nullptr;
-  // This isn't necessary the hash value we will have in the new FlowGraph, but
-  // it will be how this type is referred to by TypeRefs in the serialized one.
-  auto const old_hash = is_recursive ? hash_sexp->value() : 0;
-  ZoneGrowableArray<TypeRef*>* pending_typerefs = nullptr;
-  if (is_recursive) {
-    if (pending_typeref_map_.LookupValue(old_hash) != nullptr) {
-      StoreError(sexp, "already parsing a type with hash %" Pd64 "",
-                 hash_sexp->value());
-      return false;
-    }
-    pending_typerefs = new (zone()) ZoneGrowableArray<TypeRef*>(zone(), 2);
-    pending_typeref_map_.Insert(old_hash, pending_typerefs);
-  }
-
-  const auto cls_sexp = CheckTaggedList(Retrieve(list, 1), "Class");
-  if (cls_sexp == nullptr) {
-    // TODO(sstrickl): Handle types not derived from classes.
-    StoreError(list, "non-class types not currently handled");
-    return false;
-  }
-  TokenPosition token_pos = TokenPosition::kNoSource;
-  if (const auto pos_sexp = CheckInteger(list->ExtraLookupValue("token_pos"))) {
-    token_pos = TokenPosition::Deserialize(pos_sexp->value());
-  }
-  auto type_args_ptr = &Object::null_type_arguments();
-  if (const auto ta_sexp = list->ExtraLookupValue("type_args")) {
-    // ParseTypeArguments may re-enter ParseType after setting the contents of
-    // the passed in handle, so we need to allocate a new handle here.
-    auto& type_args = TypeArguments::Handle(zone());
-    if (!ParseTypeArguments(ta_sexp, &type_args)) return false;
-    type_args_ptr = &type_args;
-  }
-  // Guaranteed not to re-enter ParseType.
-  if (!ParseClass(cls_sexp, &type_class_)) return false;
-  const Nullability nullability =
-      type_class_.IsNullClass() ? Nullability::kNullable : Nullability::kLegacy;
-  *out = Type::New(type_class_, *type_args_ptr, nullability);
-  auto& type = Type::Cast(*out);
-  if (is_recursive) {
-    while (!pending_typerefs->is_empty()) {
-      auto const ref = pending_typerefs->RemoveLast();
-      ASSERT(ref != nullptr);
-      ref->set_type(type);
-    }
-    pending_typeref_map_.Remove(old_hash);
-
-    // If there are still pending typerefs, we can't canonicalize yet until
-    // an enclosing type where we have resolved them. This is a conservative
-    // check, as we do not ensure that any of the still-pending typerefs are
-    // found within this type.
-    //
-    // This is within the is_recursive check because if this type was
-    // non-recursive, then even if there are pending type refs, we are
-    // guaranteed that none of them are in this type.
-    if (ArePendingTypeRefs()) return true;
-  }
-
-  // Need to set this for canonicalization. We ensure in the serializer
-  // that only finalized types are successfully serialized.
-  type.SetIsFinalized();
-  return CanonicalizeInstance(list, out);
-}
-
-bool FlowGraphDeserializer::ParseTypeArguments(SExpression* sexp, Object* out) {
-  ASSERT(out != nullptr);
-  if (sexp == nullptr) return false;
-
-  if (auto const sym = sexp->AsSymbol()) {
-    auto const val = ParseValue(sexp, /*allow_pending=*/false);
-    if (val == nullptr) {
-      StoreError(sexp,
-                 "expected type arguments or reference to constant definition");
-      return false;
-    }
-    if (!val->BindsToConstant()) {
-      StoreError(sexp, "reference to non-constant definition");
-      return false;
-    }
-    *out = val->BoundConstant().ptr();
-    if (!out->IsTypeArguments()) {
-      StoreError(sexp, "expected TypeArguments constant");
-      return false;
-    }
-    return true;
-  }
-  auto const list = CheckTaggedList(sexp, "TypeArguments");
-  if (list == nullptr) return false;
-
-  *out = TypeArguments::New(list->Length() - 1, Heap::kOld);
-  auto& type_args = TypeArguments::Cast(*out);
-  // We may reenter ParseTypeArguments while parsing one of the elements, so we
-  // need a fresh handle here.
-  auto& elem = AbstractType::Handle(zone());
-  for (intptr_t i = 1, n = list->Length(); i < n; i++) {
-    if (!ParseAbstractType(Retrieve(list, i), &elem)) return false;
-    type_args.SetTypeAt(i - 1, elem);
-  }
-
-  // If there are still pending typerefs, we can't canonicalize yet.
-  if (ArePendingTypeRefs()) return true;
-
-  return CanonicalizeInstance(list, out);
-}
-
-bool FlowGraphDeserializer::ParseTypeParameter(SExpList* list, Object* out) {
-  ASSERT(out != nullptr);
-  if (list == nullptr) return false;
-
-  Class& cls = Class::Handle();
-  if (auto const cid_sexp = CheckInteger(list->ExtraLookupValue("cid"))) {
-    const intptr_t cid = cid_sexp->value();
-    ClassTable* table = thread()->isolate_group()->class_table();
-    if (!table->HasValidClassAt(cid)) {
-      StoreError(cid_sexp, "no valid class found for cid");
-      return false;
-    }
-    cls = table->At(cid);
-  } else {
-    return false;
-  }
-  auto const base_sexp = CheckInteger(list->ExtraLookupValue("base"));
-  if (base_sexp == nullptr) return false;
-  intptr_t base = base_sexp->value();
-  auto const index_sexp = CheckInteger(list->ExtraLookupValue("index"));
-  if (index_sexp == nullptr) return false;
-  intptr_t index = index_sexp->value();
-  auto const name_sexp = CheckSymbol(Retrieve(list, 1));
-  if (name_sexp == nullptr) return false;
-  tmp_string_ = String::New(name_sexp->value());
-
-  *out =
-      TypeParameter::New(cls, base, index, tmp_string_, Object::dynamic_type(),
-                         false, Nullability::kLegacy);
-  TypeParameter::Cast(*out).SetIsFinalized();
-  return CanonicalizeInstance(list, out);
-}
-
-bool FlowGraphDeserializer::ParseTypeRef(SExpList* list, Object* out) {
-  ASSERT(out != nullptr);
-  if (list == nullptr) return false;
-
-  const bool contains_type = list->Length() > 1;
-  if (contains_type) {
-    auto& type = Type::Handle(zone());
-    if (!ParseAbstractType(Retrieve(list, 1), &type)) return false;
-    *out = TypeRef::New(type);
-    // If the TypeRef appears outside the referrent, then the referrent
-    // should be already canonicalized. This serves as a double-check that
-    // is the case.
-    return CanonicalizeInstance(list, out);
-  }
-  // If there is no type in the body, then this must be a referrent to
-  // a Type containing this TypeRef. That means we must have a hash value.
-  auto const hash_sexp = CheckInteger(Retrieve(list, "hash"));
-  if (hash_sexp == nullptr) return false;
-  auto const old_hash = hash_sexp->value();
-  auto const pending = pending_typeref_map_.LookupValue(old_hash);
-  if (pending == nullptr) {
-    StoreError(list, "reference to recursive type found outside type");
-    return false;
-  }
-  *out = TypeRef::New(Object::null_abstract_type());
-  pending->Add(static_cast<TypeRef*>(out));
-
-  // We can only canonicalize TypeRefs appearing within their referrent
-  // when its containing value is canonicalized.
-  return true;
-}
-
-bool FlowGraphDeserializer::ParseCanonicalName(SExpSymbol* sym, Object* obj) {
-  ASSERT(obj != nullptr);
-  if (sym == nullptr) return false;
-  auto const name = sym->value();
-  // TODO(sstrickl): No library URL, handle this better.
-  if (*name == ':') {
-    StoreError(sym, "expected non-empty library");
-    return false;
-  }
-  const char* lib_end = nullptr;
-  if (auto const first = strchr(name, ':')) {
-    lib_end = strchr(first + 1, ':');
-    if (lib_end == nullptr) lib_end = strchr(first + 1, '\0');
-  } else {
-    StoreError(sym, "malformed library");
-    return false;
-  }
-  tmp_string_ =
-      String::FromUTF8(reinterpret_cast<const uint8_t*>(name), lib_end - name);
-  name_library_ = Library::LookupLibrary(thread(), tmp_string_);
-  if (*lib_end == '\0') {
-    *obj = name_library_.ptr();
-    return true;
-  }
-  const char* const class_start = lib_end + 1;
-  if (*class_start == '\0') {
-    StoreError(sym, "no class found after colon");
-    return false;
-  }
-  // If classes are followed by another part, it's either a function
-  // (separated by ':') or a field (separated by '.').
-  const char* class_end = strchr(class_start, ':');
-  if (class_end == nullptr) class_end = strchr(class_start, '.');
-  if (class_end == nullptr) class_end = strchr(class_start, '\0');
-  const bool empty_name = class_end == class_start;
-  name_class_ = Class::null();
-  if (empty_name) {
-    name_class_ = name_library_.toplevel_class();
-  } else {
-    tmp_string_ = String::FromUTF8(
-        reinterpret_cast<const uint8_t*>(class_start), class_end - class_start);
-    name_class_ = name_library_.LookupClassAllowPrivate(tmp_string_);
-  }
-  if (name_class_.IsNull()) {
-    StoreError(sym, "failure looking up class %s in library %s",
-               empty_name ? "at top level" : tmp_string_.ToCString(),
-               name_library_.ToCString());
-    return false;
-  }
-  if (*class_end == '\0') {
-    *obj = name_class_.ptr();
-    return true;
-  }
-  if (*class_end == '.') {
-    if (class_end[1] == '\0') {
-      StoreError(sym, "no field name found after period");
-      return false;
-    }
-    const char* const field_start = class_end + 1;
-    const char* field_end = strchr(field_start, '\0');
-    tmp_string_ = String::FromUTF8(
-        reinterpret_cast<const uint8_t*>(field_start), field_end - field_start);
-    name_field_ = name_class_.LookupFieldAllowPrivate(tmp_string_);
-    if (name_field_.IsNull()) {
-      StoreError(sym, "failure looking up field %s in class %s",
-                 tmp_string_.ToCString(),
-                 empty_name ? "at top level" : name_class_.ToCString());
-      return false;
-    }
-    *obj = name_field_.ptr();
-    return true;
-  }
-  if (class_end[1] == '\0') {
-    StoreError(sym, "no function name found after final colon");
-    return false;
-  }
-  const char* func_start = class_end + 1;
-  name_function_ = Function::null();
-  while (true) {
-    const char* func_end = strchr(func_start, ':');
-    intptr_t name_len = func_end - func_start;
-    bool is_forwarder = false;
-    if (func_end != nullptr && name_len == 3) {
-      // Special case for getters/setters, where they are prefixed with "get:"
-      // or "set:", as those colons should not be used as separators.
-      if (strncmp(func_start, "get", 3) == 0 ||
-          strncmp(func_start, "set", 3) == 0) {
-        func_end = strchr(func_end + 1, ':');
-      } else if (strncmp(func_start, "dyn", 3) == 0) {
-        // Dynamic invocation forwarders start with "dyn:" and we'll need to
-        // look up the base function and then retrieve the forwarder from it.
-        is_forwarder = true;
-        func_start = func_end + 1;
-        func_end = strchr(func_end + 1, ':');
-      }
-    }
-    if (func_end == nullptr) func_end = strchr(func_start, '\0');
-    name_len = func_end - func_start;
-
-    // Check for tearoff names before we overwrite the contents of tmp_string_.
-    if (!name_function_.IsNull()) {
-      ASSERT(!tmp_string_.IsNull());
-      auto const parent_name = tmp_string_.ToCString();
-      // ImplicitClosureFunctions (tearoffs) have the same name as the Function
-      // to which they are attached. We currently don't handle any other kinds
-      // of local functions.
-      if (name_function_.HasImplicitClosureFunction() && *func_end == '\0' &&
-          strncmp(parent_name, func_start, name_len) == 0) {
-        *obj = name_function_.ImplicitClosureFunction();
-        return true;
-      }
-      StoreError(sym, "no handling for local functions");
-      return false;
-    }
-
-    // Check for the prefix "<anonymous ..." in the name and fail if found,
-    // since we can't resolve these.
-    static auto const anon_prefix = "<anonymous ";
-    static const intptr_t prefix_len = strlen(anon_prefix);
-    if ((name_len > prefix_len) &&
-        strncmp(anon_prefix, func_start, prefix_len) == 0) {
-      StoreError(sym, "cannot resolve anonymous values");
-      return false;
-    }
-
-    tmp_string_ = String::FromUTF8(reinterpret_cast<const uint8_t*>(func_start),
-                                   name_len);
-    name_function_ = name_class_.LookupFunctionAllowPrivate(tmp_string_);
-    if (name_function_.IsNull()) {
-      StoreError(sym, "failure looking up function %s in class %s",
-                 tmp_string_.ToCString(), name_class_.ToCString());
-      return false;
-    }
-    if (is_forwarder) {
-      tmp_string_ = name_function_.name();
-      tmp_string_ = Function::CreateDynamicInvocationForwarderName(tmp_string_);
-      name_function_ =
-          name_function_.GetDynamicInvocationForwarder(tmp_string_);
-    }
-    if (func_end[0] == '\0') break;
-    if (func_end[1] == '\0') {
-      StoreError(sym, "no function name found after final colon");
-      return false;
-    }
-    func_start = func_end + 1;
-  }
-  *obj = name_function_.ptr();
-  return true;
-}
-
-bool FlowGraphDeserializer::ParseSlot(SExpList* list, const Slot** out) {
-  ASSERT(out != nullptr);
-  const auto offset_sexp = CheckInteger(Retrieve(list, 1));
-  if (offset_sexp == nullptr) return false;
-  const auto offset = offset_sexp->value();
-
-  const auto kind_sexp = CheckSymbol(Retrieve(list, "kind"));
-  if (kind_sexp == nullptr) return false;
-  Slot::Kind kind;
-  if (!Slot::ParseKind(kind_sexp->value(), &kind)) {
-    StoreError(kind_sexp, "unknown Slot kind");
-    return false;
-  }
-
-  switch (kind) {
-    case Slot::Kind::kDartField: {
-      auto& field = Field::ZoneHandle(zone());
-      const auto field_sexp = CheckTaggedList(Retrieve(list, "field"), "Field");
-      if (!ParseDartValue(field_sexp, &field)) return false;
-      ASSERT(parsed_function_ != nullptr);
-      *out =
-          &Slot::Get(kernel::BaseFlowGraphBuilder::MayCloneField(zone(), field),
-                     parsed_function_);
-      break;
-    }
-    case Slot::Kind::kTypeArguments:
-      *out = &Slot::GetTypeArgumentsSlotAt(thread(), offset);
-      break;
-    case Slot::Kind::kTypeArgumentsIndex:
-      *out = &Slot::GetTypeArgumentsIndexSlot(thread(), offset);
-      break;
-    case Slot::Kind::kArrayElement:
-      *out = &Slot::GetArrayElementSlot(thread(), offset);
-      break;
-    case Slot::Kind::kCapturedVariable:
-      StoreError(kind_sexp, "unhandled Slot kind");
-      return false;
-    default:
-      *out = &Slot::GetNativeSlot(kind);
-      break;
-  }
-  return true;
-}
-
-bool FlowGraphDeserializer::ParseRange(SExpList* list, Range* out) {
-  if (list == nullptr) return false;
-  RangeBoundary min, max;
-  if (!ParseRangeBoundary(Retrieve(list, 1), &min)) return false;
-  if (list->Length() == 2) {
-    max = min;
-  } else {
-    if (!ParseRangeBoundary(Retrieve(list, 2), &max)) return false;
-  }
-  out->min_ = min;
-  out->max_ = max;
-  return true;
-}
-
-bool FlowGraphDeserializer::ParseRangeBoundary(SExpression* sexp,
-                                               RangeBoundary* out) {
-  if (sexp == nullptr) return false;
-  if (auto const int_sexp = sexp->AsInteger()) {
-    out->kind_ = RangeBoundary::Kind::kConstant;
-    out->value_ = int_sexp->value();
-  } else if (auto const sym_sexp = sexp->AsSymbol()) {
-    if (!RangeBoundary::ParseKind(sym_sexp->value(), &out->kind_)) return false;
-  } else if (auto const list_sexp = sexp->AsList()) {
-    intptr_t index;
-    if (!ParseUse(CheckSymbol(Retrieve(list_sexp, 1)), &index)) return false;
-    auto const def = definition_map_.LookupValue(index);
-    if (def == nullptr) {
-      StoreError(list_sexp, "no definition for symbolic range boundary");
-      return false;
-    }
-    out->kind_ = RangeBoundary::Kind::kSymbol;
-    out->value_ = reinterpret_cast<intptr_t>(def);
-    if (auto const offset_sexp =
-            CheckInteger(list_sexp->ExtraLookupValue("offset"))) {
-      auto const offset = offset_sexp->value();
-      if (!RangeBoundary::IsValidOffsetForSymbolicRangeBoundary(offset)) {
-        StoreError(sexp, "invalid offset for symbolic range boundary");
-        return false;
-      }
-      out->offset_ = offset;
-    }
-  } else {
-    StoreError(sexp, "unexpected value for range boundary");
-    return false;
-  }
-  return true;
-}
-
-bool FlowGraphDeserializer::ParseBlockId(SExpSymbol* sym, intptr_t* out) {
-  return ParseSymbolAsPrefixedInt(sym, 'B', out);
-}
-
-bool FlowGraphDeserializer::ParseSSATemp(SExpSymbol* sym, intptr_t* out) {
-  return ParseSymbolAsPrefixedInt(sym, 'v', out);
-}
-
-bool FlowGraphDeserializer::ParseUse(SExpSymbol* sym, intptr_t* out) {
-  // TODO(sstrickl): Handle non-SSA temp uses.
-  return ParseSSATemp(sym, out);
-}
-
-bool FlowGraphDeserializer::ParseSymbolAsPrefixedInt(SExpSymbol* sym,
-                                                     char prefix,
-                                                     intptr_t* out) {
-  ASSERT(out != nullptr);
-  if (sym == nullptr) return false;
-  auto const name = sym->value();
-  if (*name != prefix) {
-    StoreError(sym, "expected symbol starting with '%c'", prefix);
-    return false;
-  }
-  int64_t i;
-  if (!OS::StringToInt64(name + 1, &i)) {
-    StoreError(sym, "expected number following symbol prefix '%c'", prefix);
-    return false;
-  }
-  *out = i;
-  return true;
-}
-
-bool FlowGraphDeserializer::ArePendingTypeRefs() const {
-  // We'll do a deep check, because while there may be recursive types still
-  // being parsed, if there are no pending type refs to those recursive types,
-  // we're still good to canonicalize.
-  if (pending_typeref_map_.IsEmpty()) return false;
-  auto it = pending_typeref_map_.GetIterator();
-  while (auto kv = it.Next()) {
-    if (!kv->value->is_empty()) return true;
-  }
-  return false;
-}
-
-bool FlowGraphDeserializer::CreateICData(SExpList* list, Instruction* inst) {
-  ASSERT(inst != nullptr);
-  if (list == nullptr) return false;
-
-  const String* function_name = nullptr;
-  Array& arguments_descriptor = Array::Handle(zone());
-  intptr_t num_args_checked;
-  ICData::RebindRule rebind_rule;
-
-  if (auto const call = inst->AsInstanceCall()) {
-    function_name = &call->function_name();
-    arguments_descriptor = call->GetArgumentsDescriptor();
-    num_args_checked = call->checked_argument_count();
-    rebind_rule = ICData::RebindRule::kInstance;
-  } else if (auto const call = inst->AsStaticCall()) {
-    function_name = &String::Handle(zone(), call->function().name());
-    arguments_descriptor = call->GetArgumentsDescriptor();
-    num_args_checked =
-        MethodRecognizer::NumArgsCheckedForStaticCall(call->function());
-    rebind_rule = ICData::RebindRule::kStatic;
-  } else {
-    StoreError(list, "unexpected instruction type for ICData");
-    return false;
-  }
-
-  auto type_ptr = &Object::null_abstract_type();
-  if (auto const type_sexp = list->ExtraLookupValue("receivers_static_type")) {
-    auto& type = AbstractType::ZoneHandle(zone());
-    if (!ParseAbstractType(type_sexp, &type)) return false;
-    type_ptr = &type;
-  }
-
-  ASSERT(parsed_function_ != nullptr);
-  auto& ic_data = ICData::ZoneHandle(
-      zone(), ICData::New(parsed_function_->function(), *function_name,
-                          arguments_descriptor, inst->deopt_id(),
-                          num_args_checked, rebind_rule, *type_ptr));
-
-  if (auto const is_mega_sexp =
-          CheckBool(list->ExtraLookupValue("is_megamorphic"))) {
-    ic_data.set_is_megamorphic(is_mega_sexp->value());
-  }
-
-  auto const class_table = thread()->isolate_group()->class_table();
-  GrowableArray<intptr_t> class_ids(zone(), 2);
-  for (intptr_t i = 1, n = list->Length(); i < n; i++) {
-    auto const entry = CheckList(Retrieve(list, i));
-    if (entry == nullptr) return false;
-    ASSERT(ic_data.NumArgsTested() == entry->Length());
-
-    intptr_t count = 0;
-    if (auto const count_sexp =
-            CheckInteger(entry->ExtraLookupValue("count"))) {
-      count = count_sexp->value();
-    }
-
-    auto& target = Function::ZoneHandle(zone());
-    if (!ParseDartValue(Retrieve(entry, "target"), &target)) return false;
-
-    // We can't use AddCheck for NumArgsTested < 2. We'll handle 0 here, and
-    // 1 after the for loop.
-    if (entry->Length() == 0) {
-      if (count != 0) {
-        StoreError(entry, "expected a zero count for no checked args");
-        return false;
-      }
-      ic_data = ICData::NewForStaticCall(parsed_function_->function(), target,
-                                         arguments_descriptor, inst->deopt_id(),
-                                         num_args_checked, rebind_rule);
-      continue;
-    }
-
-    class_ids.Clear();
-    for (intptr_t j = 0, num_cids = entry->Length(); j < num_cids; j++) {
-      auto const cid_sexp = CheckInteger(Retrieve(entry, j));
-      if (cid_sexp == nullptr) return false;
-      const intptr_t cid = cid_sexp->value();
-      // kObjectCid is a special case used for AddTarget() entries with
-      // a non-zero number of checked arguments.
-      if (cid != kObjectCid && !class_table->HasValidClassAt(cid)) {
-        StoreError(cid_sexp, "cid is not a valid class");
-        return false;
-      }
-      class_ids.Add(cid);
-    }
-
-    if (entry->Length() == 1) {
-      ic_data.AddReceiverCheck(class_ids.At(0), target, count);
-    } else {
-      ic_data.AddCheck(class_ids, target, count);
-    }
-  }
-
-  if (auto const call = inst->AsInstanceCall()) {
-    call->set_ic_data(const_cast<const ICData*>(&ic_data));
-  } else if (auto const call = inst->AsStaticCall()) {
-    call->set_ic_data(&ic_data);
-  }
-
-  return true;
-}
-
-Value* FlowGraphDeserializer::AddNewPendingValue(SExpression* sexp,
-                                                 intptr_t index,
-                                                 bool inherit_type) {
-  ASSERT(flow_graph_ != nullptr);
-  auto const value = new (zone()) Value(flow_graph_->constant_null());
-  ASSERT(!definition_map_.HasKey(index));
-  auto list = values_map_.LookupValue(index);
-  if (list == nullptr) {
-    list = new (zone()) ZoneGrowableArray<PendingValue>(zone(), 2);
-    values_map_.Insert(index, list);
-  }
-  list->Add({sexp, value, inherit_type});
-  return value;
-}
-
-bool FlowGraphDeserializer::FixPendingValues(intptr_t index, Definition* def) {
-  if (auto value_list = values_map_.LookupValue(index)) {
-    for (intptr_t i = 0; i < value_list->length(); i++) {
-      const auto& value_info = value_list->At(i);
-      auto const value = value_info.value;
-      const bool inherit_type = value_info.inherit_type;
-      value->BindTo(def);
-      if (!inherit_type) continue;
-      if (def->HasType()) {
-        value->reaching_type_ = def->Type();
-      } else {
-        StoreError(value_info.sexp, "value inherits type, but no type found");
-        return false;
-      }
-    }
-    values_map_.Remove(index);
-  }
-  return true;
-}
-
-BlockEntryInstr* FlowGraphDeserializer::FetchBlock(SExpSymbol* sym) {
-  if (sym == nullptr) return nullptr;
-  intptr_t block_id;
-  if (!ParseBlockId(sym, &block_id)) return nullptr;
-  auto const entry = block_map_.LookupValue(block_id);
-  if (entry == nullptr) {
-    StoreError(sym, "reference to undefined block");
-    return nullptr;
-  }
-  return entry;
-}
-
-#define BASE_CHECK_DEF(name, type)                                             \
-  SExp##name* FlowGraphDeserializer::Check##name(SExpression* sexp) {          \
-    if (sexp == nullptr) return nullptr;                                       \
-    if (!sexp->Is##name()) {                                                   \
-      StoreError(sexp, "expected " #name);                                     \
-      return nullptr;                                                          \
-    }                                                                          \
-    return sexp->As##name();                                                   \
-  }
-
-FOR_EACH_S_EXPRESSION(BASE_CHECK_DEF)
-
-#undef BASE_CHECK_DEF
-
-bool FlowGraphDeserializer::IsTag(SExpression* sexp, const char* label) {
-  auto const sym = CheckSymbol(sexp);
-  if (sym == nullptr) return false;
-  if (label != nullptr && !sym->Equals(label)) {
-    StoreError(sym, "expected symbol %s", label);
-    return false;
-  }
-  return true;
-}
-
-SExpList* FlowGraphDeserializer::CheckTaggedList(SExpression* sexp,
-                                                 const char* label) {
-  auto const list = CheckList(sexp);
-  const intptr_t tag_pos = 0;
-  if (!IsTag(Retrieve(list, tag_pos), label)) return nullptr;
-  return list;
-}
-
-void FlowGraphDeserializer::StoreError(SExpression* sexp,
-                                       const char* format,
-                                       ...) {
-  va_list args;
-  va_start(args, format);
-  const char* const message = OS::VSCreate(zone(), format, args);
-  va_end(args);
-  error_sexp_ = sexp;
-  error_message_ = message;
-}
-
-void FlowGraphDeserializer::ReportError() const {
-  ASSERT(error_sexp_ != nullptr);
-  ASSERT(error_message_ != nullptr);
-  OS::PrintErr("Unable to deserialize flow_graph: %s\n", error_message_);
-  OS::PrintErr("Error at S-expression %s\n", error_sexp_->ToCString(zone()));
-  OS::Abort();
-}
-
-}  // namespace dart
diff --git a/runtime/vm/compiler/backend/il_deserializer.h b/runtime/vm/compiler/backend/il_deserializer.h
deleted file mode 100644
index 5049850..0000000
--- a/runtime/vm/compiler/backend/il_deserializer.h
+++ /dev/null
@@ -1,421 +0,0 @@
-// Copyright (c) 2019, 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.
-
-#ifndef RUNTIME_VM_COMPILER_BACKEND_IL_DESERIALIZER_H_
-#define RUNTIME_VM_COMPILER_BACKEND_IL_DESERIALIZER_H_
-
-#if defined(DART_PRECOMPILED_RUNTIME)
-#error "AOT runtime should not use compiler sources (including header files)"
-#endif  // defined(DART_PRECOMPILED_RUNTIME)
-
-#include "platform/assert.h"
-
-#include "vm/allocation.h"
-#include "vm/compiler/backend/flow_graph.h"
-#include "vm/compiler/backend/il.h"
-#include "vm/compiler/backend/sexpression.h"
-#include "vm/compiler/compiler_pass.h"
-#include "vm/object.h"
-#include "vm/parser.h"
-#include "vm/thread.h"
-#include "vm/zone.h"
-
-namespace dart {
-
-// Deserializes FlowGraphs from S-expressions.
-class FlowGraphDeserializer : ValueObject {
- public:
-  // Adds to the given array all the instructions in the flow graph that are
-  // guaranteed not to be handled by the current implementation of the
-  // FlowGraphDeserializer. This way, we can filter out graphs that are
-  // guaranteed not to be deserializable before going through the round-trip
-  // serialization process.
-  //
-  // Note that there may be other reasons that the deserializer may fail on
-  // a given flow graph, so no new members of the array is necessary, but not
-  // sufficient, for a successful round-trip pass.
-  static void AllUnhandledInstructions(const FlowGraph* graph,
-                                       GrowableArray<Instruction*>* out);
-
-  // Takes the FlowGraph from [state] and runs it through the serializer
-  // and deserializer. If the deserializer successfully deserializes the
-  // graph, then the FlowGraph in [state] is replaced with the new one.
-  static void RoundTripSerialization(CompilerPassState* state);
-
-  FlowGraphDeserializer(Thread* thread,
-                        Zone* zone,
-                        SExpression* root,
-                        const ParsedFunction* pf = nullptr)
-      : thread_(ASSERT_NOTNULL(thread)),
-        zone_(ASSERT_NOTNULL(zone)),
-        root_sexp_(ASSERT_NOTNULL(root)),
-        parsed_function_(pf),
-        block_map_(zone),
-        definition_map_(zone),
-        values_map_(zone),
-        recursive_types_map_(zone),
-        pending_typeref_map_(zone),
-        array_type_args_(TypeArguments::Handle(zone)),
-        instance_class_(Class::Handle(zone)),
-        instance_field_(Field::Handle(zone)),
-        instance_fields_array_(Array::Handle(zone)),
-        instance_type_args_(TypeArguments::Handle(zone)),
-        name_class_(Class::Handle(zone)),
-        name_field_(Field::Handle(zone)),
-        name_function_(Function::Handle(zone)),
-        name_library_(Library::Handle(zone)),
-        type_class_(Class::Handle(zone)),
-        type_param_class_(Class::Handle(zone)),
-        tmp_string_(String::Handle(zone)) {
-    // See canonicalization comment in ParseDartValue as to why this is
-    // currently necessary.
-    ASSERT(thread->zone() == zone);
-  }
-
-  // Walks [root_sexp_] and constructs a new FlowGraph.
-  FlowGraph* ParseFlowGraph();
-
-  const char* error_message() const { return error_message_; }
-  SExpression* error_sexp() const { return error_sexp_; }
-
-  // Prints the current error information to stderr and aborts.
-  DART_NORETURN void ReportError() const;
-
- private:
-#define FOR_EACH_HANDLED_BLOCK_TYPE_IN_DESERIALIZER(M)                         \
-  M(FunctionEntry)                                                             \
-  M(GraphEntry)                                                                \
-  M(JoinEntry)                                                                 \
-  M(TargetEntry)
-
-#define FOR_EACH_HANDLED_INSTRUCTION_IN_DESERIALIZER(M)                        \
-  M(AllocateObject)                                                            \
-  M(AssertAssignable)                                                          \
-  M(AssertBoolean)                                                             \
-  M(BooleanNegate)                                                             \
-  M(Branch)                                                                    \
-  M(CheckNull)                                                                 \
-  M(CheckStackOverflow)                                                        \
-  M(Constant)                                                                  \
-  M(DebugStepCheck)                                                            \
-  M(Goto)                                                                      \
-  M(InstanceCall)                                                              \
-  M(LoadClassId)                                                               \
-  M(LoadField)                                                                 \
-  M(NativeCall)                                                                \
-  M(Parameter)                                                                 \
-  M(Return)                                                                    \
-  M(SpecialParameter)                                                          \
-  M(StaticCall)                                                                \
-  M(StoreInstanceField)                                                        \
-  M(StrictCompare)                                                             \
-  M(Throw)
-
-  // Helper methods for AllUnhandledInstructions.
-  static bool IsHandledInstruction(Instruction* inst);
-  static bool IsHandledConstant(const Object& obj);
-
-  // **GENERAL DESIGN NOTES FOR PARSING METHODS**
-  //
-  // For functions that take an SExpression or a subclass, they should return
-  // an error signal (false, nullptr, etc.) without changing the error state if
-  // passed in nullptr. This way, methods can be chained without intermediate
-  // checking.
-  //
-  // Also, for parsing methods for expressions that are known to be of a certain
-  // form, they will take the appropriate subclass of SExpression and assume
-  // that the form was already pre-checked by the caller. For forms that are
-  // tagged lists, this includes the fact that there is at least one element
-  // and the first element is a symbol. If the form can only have one possible
-  // tag, they also assume the tag has already been checked.
-
-  // Helper functions that do length/key exists checking and also check that
-  // the retrieved element is not nullptr. Notably, do not use these if the
-  // retrieved element is optional, to avoid changing the error state
-  // unnecessarily.
-  SExpression* Retrieve(SExpList* list, intptr_t index);
-  SExpression* Retrieve(SExpList* list, const char* key);
-
-  bool ParseConstantPool(SExpList* pool);
-  bool ParseEntries(SExpList* list);
-
-  using BlockWorklist = GrowableArray<intptr_t>;
-
-  // Starts parsing the contents of [list], where the blocks begin at position
-  // [pos] and [worklist] contains the blocks whose body instructions should
-  // be parsed first.
-  bool ParseBlocks(SExpList* list, intptr_t pos, BlockWorklist* worklist);
-
-  // Block parsing is split into two passes. This pass adds function entries
-  // to the flow graph and also parses initial definitions found in the Entries
-  // list. The block is added to the [block_map_] before returning.
-  BlockEntryInstr* ParseBlockHeader(SExpList* list,
-                                    intptr_t block_id,
-                                    SExpSymbol* tag);
-
-  // Expects [current_block_] to be set before calling.
-  bool ParseInitialDefinitions(SExpList* list);
-
-  // Expects [current_block_] to be set before calling.
-  // Takes the tagged list to parse and the index where parsing should start.
-  // Attempts to parse Phi definitions until the first non-Phi instruction.
-  bool ParsePhis(SExpList* list);
-
-  // Expects [current_block_] to be set before calling.
-  // Returns the position of the first non-Phi instruction in a block.
-  intptr_t SkipPhis(SExpList* list);
-
-  // Parses the deopt environment, Phi definitions for JoinEntrys, and the
-  // instructions in the body of the block. Adds the IDs of the block successors
-  // to the worklist, if any. [current_block_] and [pushed_stack_] must be set
-  // before calling.
-  bool ParseBlockContents(SExpList* list, BlockWorklist* worklist);
-
-  // Helper function used by ParseConstantPool, ParsePhis, and ParseDefinition.
-  // This handles all the extra information stored in (def ...) expressions,
-  // and also ensures the index of the definition is appropriately adjusted to
-  // match those found in the serialized form.
-  bool ParseDefinitionWithParsedBody(SExpList* list, Definition* def);
-
-  Definition* ParseDefinition(SExpList* list);
-  Instruction* ParseInstruction(SExpList* list);
-
-  struct EntryInfo {
-    intptr_t block_id;
-    intptr_t try_index;
-    intptr_t deopt_id;
-  };
-
-#define HANDLER_DECL(name)                                                     \
-  name##Instr* Deserialize##name(SExpList* list, const EntryInfo& info);
-
-  FOR_EACH_HANDLED_BLOCK_TYPE_IN_DESERIALIZER(HANDLER_DECL);
-
-#undef HANDLER_DECL
-
-  struct InstrInfo {
-    const intptr_t deopt_id;
-    const InstructionSource source;
-  };
-
-  enum HandledInstruction {
-#define HANDLED_INST_DECL(name) kHandled##name,
-    FOR_EACH_HANDLED_INSTRUCTION_IN_DESERIALIZER(HANDLED_INST_DECL)
-#undef HANDLED_INST_DECL
-    // clang-format off
-    kHandledInvalid = -1,
-    // clang-format on
-  };
-
-#define HANDLE_CASE(name)                                                      \
-  if (strcmp(tag->value(), #name) == 0) return kHandled##name;
-  HandledInstruction HandledInstructionForTag(SExpSymbol* tag) {
-    ASSERT(tag != nullptr);
-    FOR_EACH_HANDLED_INSTRUCTION_IN_DESERIALIZER(HANDLE_CASE)
-    return kHandledInvalid;
-  }
-#undef HANDLE_CASE
-
-#define HANDLER_DECL(name)                                                     \
-  name##Instr* Deserialize##name(SExpList* list, const InstrInfo& info);
-
-  FOR_EACH_HANDLED_INSTRUCTION_IN_DESERIALIZER(HANDLER_DECL);
-
-#undef HANDLER_DECL
-
-  // Common information parsed from call instruction S-expressions.
-  struct CallInfo : public ValueObject {
-    explicit CallInfo(Zone* zone) : argument_names(Array::ZoneHandle(zone)) {}
-
-    Array& argument_names;
-    intptr_t type_args_len = 0;
-    intptr_t args_len = 0;
-    InputsArray* inputs = nullptr;
-    CompileType* result_type = nullptr;
-    Code::EntryKind entry_kind = Code::EntryKind::kNormal;
-  };
-
-  // Helper function for parsing call instructions that returns a structure
-  // of information common to all calls.
-  bool ParseCallInfo(SExpList* call,
-                     CallInfo* out,
-                     intptr_t num_extra_inputs = 0);
-
-  // Parses [sexp] as a value form, that is, either the binding name for
-  // a definition as a symbol or the form (value <name> { ... }).
-  // If [allow_pending], then values for definitions not already in the
-  // [definition_map_] will be added to the [values_map_], otherwise,
-  // values for definitions not yet seen cause an error to be stored and
-  // nullptr to be returned.
-  Value* ParseValue(SExpression* sexp, bool allow_pending = true);
-  CompileType* ParseCompileType(SExpList* list);
-
-  // Parses [list] as an environment form: a list containing either binding
-  // names for definitions or a# for pushed arguments (where # is the depth
-  // of the argument from the top of the stack). Requires [pushed_stack_] to
-  // be set if any references to pushed arguments are found.
-  Environment* ParseEnvironment(SExpList* list);
-
-  // Parsing functions for which there are no good distinguished error
-  // values, so use out parameters and a boolean return instead.
-
-  // Parses a Dart value and returns a canonicalized result.
-  bool ParseDartValue(SExpression* sexp, Object* out);
-
-  // Canonicalizes and replaces the original contents of the handle pointed to
-  // by [inst] if [inst] is an Instance (if not, it trivially succeeds). The
-  // replacement happens whether successful or not. [sexp] is the SExpression
-  // to be used for error reporting.
-  bool CanonicalizeInstance(SExpression* sexp, Object* inst);
-
-  // Helper functions for ParseDartValue for parsing particular type of values.
-  // If necessary, they canonicalize the returned value, and so may be used
-  // directly by other code as well. Helpers that take SExpression* take either
-  // serialized constants or references to constant definitions.
-  //
-  // Due to particulars of operator=() on non-Object values, for a given X,
-  // ParseX takes Object* instead of X* for the out parameter.
-  bool ParseAbstractType(SExpression* sexp, Object* out);
-  bool ParseClass(SExpList* list, Object* out);
-  bool ParseClosure(SExpList* list, Object* out);
-  bool ParseField(SExpList* list, Object* out);
-  bool ParseFunction(SExpList* list, Object* out);
-  bool ParseSignature(SExpList* list, Object* out);
-  bool ParseArray(SExpList* list, Object* out);
-  bool ParseImmutableList(SExpList* list, Object* out);
-  bool ParseInstance(SExpList* list, Object* out);
-  bool ParseType(SExpression* sexp, Object* out);
-  bool ParseFunctionType(SExpList* list, Object* out);
-  bool ParseTypeParameter(SExpList* list, Object* out);
-  bool ParseTypeArguments(SExpression* sexp, Object* out);
-  bool ParseTypeRef(SExpList* list, Object* out);
-
-  bool ParseCanonicalName(SExpSymbol* sym, Object* out);
-
-  const Field& MayCloneField(const Field& field) const;
-  bool ParseSlot(SExpList* list, const Slot** out);
-  bool ParseRange(SExpList* list, Range* out);
-  bool ParseRangeBoundary(SExpression* sexp, RangeBoundary* out);
-
-  bool ParseBlockId(SExpSymbol* sym, intptr_t* out);
-  bool ParseSSATemp(SExpSymbol* sym, intptr_t* out);
-  bool ParseUse(SExpSymbol* sym, intptr_t* out);
-  bool ParseSymbolAsPrefixedInt(SExpSymbol* sym, char prefix, intptr_t* out);
-
-  bool ArePendingTypeRefs() const;
-
-  // Allocates a new ICData structure. [list] is the ICData S-expression, while
-  // [inst] is the Instruction generated from the instruction S-expression
-  // containing [list].
-  bool CreateICData(SExpList* list, Instruction* inst);
-
-  // Helper function for creating a placeholder value when the definition
-  // with index [i] has not yet been seen. If [inherit_type], then the type of
-  // the definition should be used as the reaching type for the use. [s] is used
-  // for any errors that occur when resolving the pending value.
-  Value* AddNewPendingValue(SExpression* s, intptr_t i, bool inherit_type);
-
-  // Helper function for rebinding values pending on this definition.
-  bool FixPendingValues(intptr_t index, Definition* def);
-
-  // Retrieves the block corresponding to the given block ID symbol from
-  // [block_map_]. Assumes all blocks have had their header parsed.
-  BlockEntryInstr* FetchBlock(SExpSymbol* sym);
-
-  // Utility functions for checking the shape of an S-expression.
-  // If these functions return nullptr for a non-null argument, they have the
-  // side effect of setting the stored error message.
-#define BASE_CHECK_DECL(name, type) SExp##name* Check##name(SExpression* sexp);
-  FOR_EACH_S_EXPRESSION(BASE_CHECK_DECL)
-#undef BASE_CHECK_DECL
-
-  // Checks whether [sexp] is a symbol with the given label.
-  bool IsTag(SExpression* sexp, const char* label);
-
-  // A version of CheckList that also checks that the list has at least one
-  // element and that the first element is a symbol. If [label] is non-null,
-  // then the initial symbol element is checked against it.
-  SExpList* CheckTaggedList(SExpression* sexp, const char* label = nullptr);
-
-  // Stores appropriate error information using the SExpression as the location
-  // and the rest of the arguments as an error message for the user.
-  void StoreError(SExpression* s, const char* fmt, ...) PRINTF_ATTRIBUTE(3, 4);
-
-  Thread* thread() const { return thread_; }
-  Zone* zone() const { return zone_; }
-
-  Thread* const thread_;
-  Zone* const zone_;
-  SExpression* const root_sexp_;
-  const ParsedFunction* parsed_function_;
-
-  FlowGraph* flow_graph_ = nullptr;
-  BlockEntryInstr* current_block_ = nullptr;
-  intptr_t max_block_id_ = -1;
-  intptr_t max_ssa_index_ = -1;
-
-  // Map from block IDs to blocks. Does not contain an entry for block 0
-  // (the graph entry), since it is only used at known points and is already
-  // available via [flow_graph_].
-  IntMap<BlockEntryInstr*> block_map_;
-
-  // Map from variable indexes to definitions.
-  IntMap<Definition*> definition_map_;
-
-  // Information needed to handle uses seen prior to their definitions.
-  struct PendingValue {
-    // SExpression used for error reporting.
-    SExpression* sexp;
-    // Value to be rebound once the right definition is found.
-    Value* value;
-    // Whether the type should inherit the type of the found definition.
-    bool inherit_type;
-  };
-
-  // Map from variable indices to lists of values. The list of values are
-  // values that were parsed prior to the corresponding definition being found.
-  IntMap<ZoneGrowableArray<PendingValue>*> values_map_;
-
-  // Map from hash values to SExpLists. This is used by ParseTypeRef to
-  // determine whether or not the recursive type it refers to is being currently
-  // built. The SExpList can be used to report hash collisions.
-  IntMap<SExpList*> recursive_types_map_;
-
-  // Map from hash values to arrays of TypeRefs. This is used by ParseType and
-  // ParseTypeRef to store and later fill in TypeRefs pending on the type being
-  // constructed. Since entries are added at the start of parsing recursive
-  // Type S-exps and removed before the resulting Type is successfully returned,
-  // this map should be empty outside of parsing recursive types.
-  IntMap<ZoneGrowableArray<TypeRef*>*> pending_typeref_map_;
-
-  // Temporary handles used by functions that are not re-entrant or where the
-  // handle is not live after the re-entrant call. Comments show which handles
-  // are expected to only be used within a single method.
-  TypeArguments& array_type_args_;     // ParseImmutableList
-  Class& instance_class_;              // ParseInstance
-  Field& instance_field_;              // ParseInstance
-  Array& instance_fields_array_;       // ParseInstance
-  TypeArguments& instance_type_args_;  // ParseInstance
-  Class& name_class_;                  // ParseCanonicalName
-  Field& name_field_;                  // ParseCanonicalName
-  Function& name_function_;            // ParseCanonicalName
-  Library& name_library_;              // ParseCanonicalName
-  Class& type_class_;                  // ParseType
-  Class& type_param_class_;            // ParseTypeParameter
-  // Uses of string handles tend to be immediate, so we only need one.
-  String& tmp_string_;
-
-  // Stores a message appropriate to surfacing to the user when an error
-  // occurs.
-  const char* error_message_ = nullptr;
-  // Stores the location of the deserialization error by containing the
-  // S-expression which caused the failure.
-  SExpression* error_sexp_ = nullptr;
-
-  DISALLOW_COPY_AND_ASSIGN(FlowGraphDeserializer);
-};
-
-}  // namespace dart
-
-#endif  // RUNTIME_VM_COMPILER_BACKEND_IL_DESERIALIZER_H_
diff --git a/runtime/vm/compiler/backend/il_serializer.cc b/runtime/vm/compiler/backend/il_serializer.cc
deleted file mode 100644
index 31fd469..0000000
--- a/runtime/vm/compiler/backend/il_serializer.cc
+++ /dev/null
@@ -1,1508 +0,0 @@
-// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-#include "vm/compiler/backend/il_serializer.h"
-
-#include "vm/compiler/backend/flow_graph.h"
-#include "vm/compiler/backend/il.h"
-#include "vm/compiler/backend/range_analysis.h"
-#include "vm/compiler/method_recognizer.h"
-#include "vm/object_store.h"
-#include "vm/os.h"
-#include "vm/zone_text_buffer.h"
-
-namespace dart {
-
-DEFINE_FLAG(bool,
-            serialize_flow_graph_types,
-            true,
-            "Serialize inferred type information in flow graphs");
-
-DEFINE_FLAG(bool,
-            verbose_flow_graph_serialization,
-            false,
-            "Serialize extra information useful for debugging");
-
-DEFINE_FLAG(bool,
-            pretty_print_serialization,
-            false,
-            "Format serialized output nicely");
-
-DECLARE_FLAG(bool, populate_llvm_constant_pool);
-
-const char* const FlowGraphSerializer::initial_indent = "";
-
-FlowGraphSerializer::FlowGraphSerializer(Zone* zone,
-                                         const FlowGraph* flow_graph)
-    : flow_graph_(ASSERT_NOTNULL(flow_graph)),
-      zone_(zone),
-      object_store_(flow_graph->thread()->isolate_group()->object_store()),
-      open_recursive_types_(zone_),
-      llvm_constants_(
-          GrowableObjectArray::Handle(zone_,
-                                      object_store_->llvm_constant_pool())),
-      llvm_functions_(
-          GrowableObjectArray::Handle(zone_,
-                                      object_store_->llvm_function_pool())),
-      llvm_constant_map_(zone_, object_store_->llvm_constant_hash_table()),
-      llvm_index_(Smi::Handle(zone_)),
-      tmp_string_(String::Handle(zone_)),
-      array_type_args_((TypeArguments::Handle(zone_))),
-      closure_context_(Context::Handle(zone_)),
-      closure_function_(Function::Handle(zone_)),
-      closure_type_args_(TypeArguments::Handle(zone_)),
-      code_owner_(Object::Handle(zone_)),
-      context_parent_(Context::Handle(zone_)),
-      context_elem_(Object::Handle(zone_)),
-      function_type_args_(TypeArguments::Handle(zone_)),
-      ic_data_target_(Function::Handle(zone_)),
-      ic_data_type_(AbstractType::Handle(zone_)),
-      instance_field_(Field::Handle(zone_)),
-      instance_type_args_(TypeArguments::Handle(zone_)),
-      serialize_library_(Library::Handle(zone_)),
-      serialize_owner_(Class::Handle(zone_)),
-      serialize_parent_(Function::Handle(zone_)),
-      type_arguments_elem_(AbstractType::Handle(zone_)),
-      type_class_(Class::Handle(zone_)),
-      type_signature_(FunctionType::Handle(zone_)),
-      type_ref_type_(AbstractType::Handle(zone_)) {
-  // Double-check that the zone in the flow graph is a parent of the
-  // zone we'll be using for serialization.
-  ASSERT(flow_graph->zone()->ContainsNestedZone(zone));
-}
-
-FlowGraphSerializer::~FlowGraphSerializer() {
-  object_store_->set_llvm_constant_hash_table(llvm_constant_map_.Release());
-}
-
-void FlowGraphSerializer::SerializeToBuffer(Zone* zone,
-                                            const FlowGraph* flow_graph,
-                                            BaseTextBuffer* buffer) {
-  ASSERT(buffer != nullptr);
-  auto const sexp = SerializeToSExp(zone, flow_graph);
-  if (FLAG_pretty_print_serialization) {
-    sexp->SerializeTo(zone, buffer, initial_indent);
-  } else {
-    sexp->SerializeToLine(buffer);
-  }
-  buffer->AddString("\n\n");
-}
-
-SExpression* FlowGraphSerializer::SerializeToSExp(Zone* zone,
-                                                  const FlowGraph* flow_graph) {
-  FlowGraphSerializer serializer(zone, flow_graph);
-  return serializer.FlowGraphToSExp();
-}
-
-#define KIND_STR(name) #name,
-static const char* block_entry_kind_tags[FlowGraphSerializer::kNumEntryKinds] =
-    {FOR_EACH_BLOCK_ENTRY_KIND(KIND_STR)};
-#undef KIND_STR
-
-FlowGraphSerializer::BlockEntryKind FlowGraphSerializer::BlockEntryTagToKind(
-    SExpSymbol* tag) {
-  if (tag == nullptr) return kTarget;
-  auto const str = tag->value();
-  for (intptr_t i = 0; i < kNumEntryKinds; i++) {
-    auto const current = block_entry_kind_tags[i];
-    if (strcmp(str, current) == 0) return static_cast<BlockEntryKind>(i);
-  }
-  return kInvalid;
-}
-
-void FlowGraphSerializer::AddBool(SExpList* sexp, bool b) {
-  sexp->Add(new (zone()) SExpBool(b));
-}
-
-void FlowGraphSerializer::AddInteger(SExpList* sexp, intptr_t i) {
-  sexp->Add(new (zone()) SExpInteger(i));
-}
-
-void FlowGraphSerializer::AddString(SExpList* sexp, const char* cstr) {
-  sexp->Add(new (zone()) SExpString(cstr));
-}
-
-void FlowGraphSerializer::AddSymbol(SExpList* sexp, const char* cstr) {
-  sexp->Add(new (zone()) SExpSymbol(cstr));
-}
-
-void FlowGraphSerializer::AddExtraBool(SExpList* sexp,
-                                       const char* label,
-                                       bool b) {
-  sexp->AddExtra(label, new (zone()) SExpBool(b));
-}
-
-void FlowGraphSerializer::AddExtraInteger(SExpList* sexp,
-                                          const char* label,
-                                          intptr_t i) {
-  sexp->AddExtra(label, new (zone()) SExpInteger(i));
-}
-
-void FlowGraphSerializer::AddExtraString(SExpList* sexp,
-                                         const char* label,
-                                         const char* cstr) {
-  sexp->AddExtra(label, new (zone()) SExpString(cstr));
-}
-
-void FlowGraphSerializer::AddExtraSymbol(SExpList* sexp,
-                                         const char* label,
-                                         const char* cstr) {
-  sexp->AddExtra(label, new (zone()) SExpSymbol(cstr));
-}
-
-SExpression* FlowGraphSerializer::BlockIdToSExp(intptr_t block_id) {
-  return new (zone()) SExpSymbol(OS::SCreate(zone(), "B%" Pd "", block_id));
-}
-
-void FlowGraphSerializer::SerializeCanonicalName(BaseTextBuffer* b,
-                                                 const Object& obj) {
-  ASSERT(!obj.IsNull());
-  if (obj.IsFunction()) {
-    const auto& function = Function::Cast(obj);
-    tmp_string_ = function.name();
-    // We only want private keys removed, no other changes.
-    tmp_string_ = String::RemovePrivateKey(tmp_string_);
-    const char* function_name = tmp_string_.ToCString();
-    // If this function is an inner closure then the parent points to its
-    // containing function, which will also be part of the canonical name.
-    //
-    // We retrieve the owner before retrieving the parent function, as the
-    // inner closure chain may be arbitrarily deep and serialize_parent_ is
-    // passed in on recursive calls. When it is, then changing serialize_parent_
-    // to the parent function also changes the contents of obj and thus we'd
-    // no longer be able to retrieve the child function or its owner.
-    //
-    // This does mean that serialize_owner_ gets overwritten for each recursive
-    // call until we reach the end of the chain, but we only use its contents at
-    // the end of the chain anyway.
-    serialize_owner_ = function.Owner();
-    serialize_parent_ = function.parent_function();
-    if (!serialize_parent_.IsNull()) {
-      SerializeCanonicalName(b, serialize_parent_);
-    } else {
-      ASSERT(!serialize_owner_.IsNull());
-      SerializeCanonicalName(b, serialize_owner_);
-    }
-    b->Printf(":%s", function_name);
-  } else if (obj.IsClass()) {
-    const auto& cls = Class::Cast(obj);
-    tmp_string_ = cls.ScrubbedName();
-    const char* class_name = tmp_string_.ToCString();
-    serialize_library_ = cls.library();
-    if (!serialize_library_.IsNull()) {
-      SerializeCanonicalName(b, serialize_library_);
-    }
-    b->Printf(":%s", class_name);
-  } else if (obj.IsLibrary()) {
-    const Library& lib = Library::Cast(obj);
-    tmp_string_ = lib.url();
-    const char* lib_name = tmp_string_.ToCString();
-    if (lib_name[0] == '\0') return;
-    b->AddString(lib_name);
-  } else if (obj.IsField()) {
-    const auto& field = Field::Cast(obj);
-    tmp_string_ = field.UserVisibleName();
-    const char* field_name = tmp_string_.ToCString();
-    serialize_owner_ = field.Owner();
-    ASSERT(!serialize_owner_.IsNull());
-    SerializeCanonicalName(b, serialize_owner_);
-    b->Printf(".%s", field_name);
-  } else {
-    UNREACHABLE();
-  }
-}
-
-SExpression* FlowGraphSerializer::CanonicalNameToSExp(const Object& obj) {
-  ASSERT(!obj.IsNull());
-  ZoneTextBuffer b(zone_, 100);
-  SerializeCanonicalName(&b, obj);
-  return new (zone()) SExpSymbol(b.buffer());
-}
-
-SExpSymbol* FlowGraphSerializer::BlockEntryKindToTag(BlockEntryKind k) {
-  ASSERT(k >= 0 && k < kNumEntryKinds);
-  return new (zone()) SExpSymbol(block_entry_kind_tags[k]);
-}
-
-#define KIND_TAG(name) block_entry_kind_tags[k##name]
-SExpSymbol* FlowGraphSerializer::BlockEntryTag(const BlockEntryInstr* entry) {
-  if (entry == nullptr) return nullptr;
-  if (entry->IsGraphEntry()) {
-    return BlockEntryKindToTag(kGraph);
-  }
-  if (entry->IsOsrEntry()) {
-    return BlockEntryKindToTag(kOSR);
-  }
-  if (entry->IsCatchBlockEntry()) {
-    return BlockEntryKindToTag(kCatch);
-  }
-  if (entry->IsIndirectEntry()) {
-    return BlockEntryKindToTag(kIndirect);
-  }
-  if (entry->IsFunctionEntry()) {
-    if (entry == flow_graph()->graph_entry()->normal_entry()) {
-      return BlockEntryKindToTag(kNormal);
-    }
-    if (entry == flow_graph()->graph_entry()->unchecked_entry()) {
-      return BlockEntryKindToTag(kUnchecked);
-    }
-  }
-  if (entry->IsJoinEntry()) {
-    return BlockEntryKindToTag(kJoin);
-  }
-  return nullptr;
-}
-#undef KIND_TAG
-
-SExpression* FlowGraphSerializer::FunctionEntryToSExp(
-    const BlockEntryInstr* entry) {
-  if (entry == nullptr) return nullptr;
-  auto sexp = new (zone()) SExpList(zone());
-  sexp->Add(BlockEntryTag(entry));
-  sexp->Add(BlockIdToSExp(entry->block_id()));
-  if (auto const with_defs = entry->AsBlockEntryWithInitialDefs()) {
-    auto const initial_defs = with_defs->initial_definitions();
-    for (intptr_t i = 0; i < initial_defs->length(); i++) {
-      sexp->Add(initial_defs->At(i)->ToSExpression(this));
-    }
-  }
-
-  // Also include the extra info here, to avoid having to find the
-  // corresponding block to get it.
-  entry->BlockEntryInstr::AddExtraInfoToSExpression(sexp, this);
-
-  return sexp;
-}
-
-SExpression* FlowGraphSerializer::EntriesToSExp(const GraphEntryInstr* start) {
-  auto sexp = new (zone()) SExpList(zone());
-  AddSymbol(sexp, "Entries");
-  if (auto const normal = FunctionEntryToSExp(start->normal_entry())) {
-    sexp->Add(normal);
-  }
-  if (auto const unchecked = FunctionEntryToSExp(start->unchecked_entry())) {
-    sexp->Add(unchecked);
-  }
-  if (auto const osr = FunctionEntryToSExp(start->osr_entry())) {
-    sexp->Add(osr);
-  }
-  for (intptr_t i = 0; i < start->catch_entries().length(); i++) {
-    sexp->Add(FunctionEntryToSExp(start->catch_entries().At(i)));
-  }
-  for (intptr_t i = 0; i < start->indirect_entries().length(); i++) {
-    sexp->Add(FunctionEntryToSExp(start->indirect_entries().At(i)));
-  }
-  return sexp;
-}
-
-SExpression* FlowGraphSerializer::FlowGraphToSExp() {
-  auto const start = flow_graph()->graph_entry();
-  auto const sexp = new (zone()) SExpList(zone());
-  AddSymbol(sexp, "FlowGraph");
-  sexp->Add(CanonicalNameToSExp(flow_graph()->function()));
-  AddExtraInteger(sexp, "deopt_id", start->deopt_id());
-  if (start->env() != nullptr) {
-    sexp->AddExtra("env", start->env()->ToSExpression(this));
-  }
-  if (start->IsCompiledForOsr()) {
-    AddExtraInteger(sexp, "osr_id", start->osr_id());
-  }
-  if (auto const constants = ConstantPoolToSExp(start)) {
-    sexp->Add(constants);
-  }
-  sexp->Add(EntriesToSExp(start));
-  auto& block_order = flow_graph()->reverse_postorder();
-  // Skip the first block, which will be the graph entry block (B0). We
-  // output all its information as part of the function expression, so it'll
-  // just show up as an empty block here.
-  ASSERT(block_order[0]->IsGraphEntry());
-  for (intptr_t i = 1; i < block_order.length(); ++i) {
-    sexp->Add(block_order[i]->ToSExpression(this));
-  }
-  if (FLAG_populate_llvm_constant_pool) {
-    auto const new_index = llvm_functions_.Length();
-    llvm_functions_.Add(flow_graph_->function());
-    AddExtraInteger(sexp, "llvm_index", new_index);
-  }
-  return sexp;
-}
-
-SExpression* FlowGraphSerializer::UseToSExp(const Definition* definition) {
-  ASSERT(definition != nullptr);
-  ASSERT(definition->HasSSATemp() || definition->HasTemp());
-  if (definition->HasSSATemp()) {
-    const intptr_t temp_index = definition->ssa_temp_index();
-    const auto name_cstr = OS::SCreate(zone(), "v%" Pd "", temp_index);
-    if (definition->HasPairRepresentation()) {
-      auto sexp = new (zone()) SExpList(zone());
-      AddSymbol(sexp, name_cstr);
-      AddSymbol(sexp, OS::SCreate(zone(), "v%" Pd "", temp_index + 1));
-      return sexp;
-    } else {
-      return new (zone()) SExpSymbol(name_cstr);
-    }
-  } else if (definition->HasTemp()) {
-    const intptr_t temp_index = definition->temp_index();
-    return new (zone()) SExpSymbol(OS::SCreate(zone(), "t%" Pd "", temp_index));
-  }
-  UNREACHABLE();
-}
-
-SExpression* FlowGraphSerializer::ClassToSExp(const Class& cls) {
-  if (cls.IsNull()) return nullptr;
-  auto sexp = new (zone()) SExpList(zone());
-  AddSymbol(sexp, "Class");
-  AddInteger(sexp, cls.id());
-  if (FLAG_verbose_flow_graph_serialization) {
-    sexp->AddExtra("name", CanonicalNameToSExp(cls));
-    // Currently, AbstractTypeToSExp assumes that serializing a class cannot
-    // re-enter it. If we make that possible by serializing parts of a class
-    // that can contain AbstractTypes, especially types that are not type
-    // parameters or type references, fix AbstractTypeToSExp appropriately.
-  }
-  return sexp;
-}
-
-static bool ShouldSerializeType(CompileType* type) {
-  return (FLAG_verbose_flow_graph_serialization ||
-          FLAG_serialize_flow_graph_types) &&
-         type != nullptr;
-}
-
-SExpression* FlowGraphSerializer::FieldToSExp(const Field& field) {
-  if (field.IsNull()) return nullptr;
-  auto sexp = new (zone()) SExpList(zone());
-  AddSymbol(sexp, "Field");
-  sexp->Add(CanonicalNameToSExp(field));
-  CompileType t(field.is_nullable(), field.guarded_cid(), nullptr);
-  if (ShouldSerializeType(&t)) {
-    sexp->AddExtra("type", t.ToSExpression(this));
-  }
-  return sexp;
-}
-
-SExpression* FlowGraphSerializer::AbstractTypeToSExp(const AbstractType& t) {
-  if (t.IsNull()) return nullptr;
-  ASSERT(t.IsFinalized());
-  auto sexp = new (zone()) SExpList(zone());
-  if (t.IsTypeParameter()) {
-    const auto& param = TypeParameter::Cast(t);
-    AddSymbol(sexp, "TypeParameter");
-    AddExtraInteger(sexp, "cid", param.parameterized_class_id());
-    AddExtraInteger(sexp, "base", param.base());
-    AddExtraInteger(sexp, "index", param.index());
-    tmp_string_ = param.name();
-    AddSymbol(sexp, tmp_string_.ToCString());
-    // TODO(regis): bound, default argument, flags, nullability, hash.
-    return sexp;
-  }
-  if (t.IsTypeRef()) {
-    const auto& ref = TypeRef::Cast(t);
-    AddSymbol(sexp, "TypeRef");
-    type_ref_type_ = ref.type();
-    auto const hash = type_ref_type_.Hash();
-    // Check to see if this is a TypeRef to a type we're currently serializing.
-    // If it is not, then we need to serialize the underlying type, as it
-    // otherwise won't be available when deserializing.
-    auto const open_type = open_recursive_types_.LookupValue(hash);
-    if (open_type == nullptr) {
-      // Allocate a new handle as we may re-enter the TypeRef branch.
-      auto& type = AbstractType::Handle(zone(), ref.type());
-      sexp->Add(AbstractTypeToSExp(type));
-      // If we serialized the referrent, then we don't need this information,
-      // but it may be useful for debugging so add it in verbose mode.
-      if (FLAG_verbose_flow_graph_serialization) {
-        AddExtraInteger(sexp, "hash", hash);
-      }
-    } else {
-      // Make sure we didn't have a hash collision.
-      ASSERT(open_type->Equals(type_ref_type_));
-      AddExtraInteger(sexp, "hash", hash);
-    }
-    if (FLAG_verbose_flow_graph_serialization) {
-      AddExtraString(sexp, "type", type_ref_type_.ToCString());
-    }
-    return sexp;
-  }
-  // We want to check for the type being recursive before we may serialize
-  // any sub-parts that include possible TypeRefs to this type.
-  const bool is_recursive = t.IsRecursive();
-  intptr_t hash = 0;
-  if (is_recursive) {
-    hash = t.Hash();
-    AddExtraInteger(sexp, "hash", hash);
-    open_recursive_types_.Insert(hash, &t);
-  }
-  if (t.IsFunctionType()) {
-    const auto& sig = FunctionType::Handle(zone(), FunctionType::Cast(t).ptr());
-    AddSymbol(sexp, "FunctionType");
-    function_type_args_ = sig.type_parameters();
-    if (auto const ta_sexp = NonEmptyTypeArgumentsToSExp(function_type_args_)) {
-      sexp->AddExtra("type_params", ta_sexp);
-    }
-    auto& type = AbstractType::Handle(zone(), sig.result_type());
-    sexp->AddExtra("result_type", AbstractTypeToSExp(type));
-    auto& parameter_types = Array::Handle(zone(), sig.parameter_types());
-    sexp->AddExtra("parameter_types", ArrayToSExp(parameter_types));
-    auto& parameter_names = Array::Handle(zone(), sig.parameter_names());
-    sexp->AddExtra("parameter_names", ArrayToSExp(parameter_names));
-    AddExtraInteger(sexp, "packed_fields", sig.packed_fields());
-    // If we were parsing a recursive type, we're now done building it, so
-    // remove it from the open recursive types.
-    if (is_recursive) open_recursive_types_.Remove(hash);
-    return sexp;
-  }
-  ASSERT(t.IsType());
-  AddSymbol(sexp, "Type");
-  const auto& type = Type::Cast(t);
-  if (type.HasTypeClass()) {
-    type_class_ = type.type_class();
-    // This avoids re-entry as long as serializing a class doesn't involve
-    // serializing concrete (non-parameter, non-reference) types.
-    sexp->Add(DartValueToSExp(type_class_));
-  } else {
-    // TODO(dartbug.com/36882): Actually structure non-class types instead of
-    // just printing out this version.
-    AddExtraString(sexp, "name", type.ToCString());
-  }
-  // Since type arguments may themselves be instantiations of generic
-  // types, we may call back into this function in the middle of printing
-  // the TypeArguments and so we must allocate a fresh handle here.
-  const auto& args = TypeArguments::Handle(zone(), type.arguments());
-  if (auto const args_sexp = NonEmptyTypeArgumentsToSExp(args)) {
-    sexp->AddExtra("type_args", args_sexp);
-  }
-  // If we were parsing a recursive type, we're now done building it, so
-  // remove it from the open recursive types.
-  if (is_recursive) open_recursive_types_.Remove(hash);
-  return sexp;
-}
-
-SExpression* FlowGraphSerializer::CodeToSExp(const Code& code) {
-  if (code.IsNull()) return nullptr;
-  auto sexp = new (zone()) SExpList(zone());
-  AddSymbol(sexp, "Code");
-  if (code.IsStubCode()) {
-    AddSymbol(sexp, StubCode::NameOfStub(code.EntryPoint()));
-    if (FLAG_verbose_flow_graph_serialization) {
-      AddExtraSymbol(sexp, "kind", "stub");
-    }
-    return sexp;
-  }
-  code_owner_ = code.owner();
-  if (!code_owner_.IsNull() && FLAG_verbose_flow_graph_serialization) {
-    if (code_owner_.IsClass()) {
-      AddExtraSymbol(sexp, "kind", "allocate");
-    } else if (code_owner_.IsAbstractType()) {
-      AddExtraSymbol(sexp, "kind", "type_test");
-    } else {
-      ASSERT(code_owner_.IsFunction());
-      AddExtraSymbol(sexp, "kind", "function");
-    }
-  }
-  sexp->Add(DartValueToSExp(code_owner_));
-  return sexp;
-}
-
-SExpression* FlowGraphSerializer::TypeArgumentsToSExp(const TypeArguments& ta) {
-  if (ta.IsNull()) return nullptr;
-  auto sexp = new (zone()) SExpList(zone());
-  AddSymbol(sexp, "TypeArguments");
-  for (intptr_t i = 0; i < ta.Length(); i++) {
-    type_arguments_elem_ = ta.TypeAt(i);
-    sexp->Add(DartValueToSExp(type_arguments_elem_));
-  }
-  if (FLAG_verbose_flow_graph_serialization && ta.IsRecursive()) {
-    AddExtraInteger(sexp, "hash", ta.Hash());
-  }
-  return sexp;
-}
-
-SExpression* FlowGraphSerializer::InstanceToSExp(const Instance& inst) {
-  if (inst.IsNull()) return nullptr;
-
-  // Since InstanceToSExp may use ObjectToSExp (via DartValueToSExp) for field
-  // values that aren't entries in the constant pool, and ObjectToSExp may
-  // re-enter InstanceToSExp, allocate fresh handles here for the argument to
-  // DartValueToSExp and other handles that are live across the call.
-  const auto& instance_class = Class::Handle(zone(), inst.clazz());
-  const auto& instance_fields_array =
-      Array::Handle(zone(), instance_class.fields());
-  auto& instance_field_value = Object::Handle(zone());
-
-  auto const sexp = new (zone()) SExpList(zone());
-  AddSymbol(sexp, "Instance");
-  AddInteger(sexp, instance_class.id());
-  auto const fields = new (zone()) SExpList(zone());
-  AddSymbol(fields, "Fields");
-  for (intptr_t i = 0; i < instance_fields_array.Length(); i++) {
-    instance_field_ = Field::RawCast(instance_fields_array.At(i));
-    // We don't need to serialize static fields, since they're shared by
-    // all instances.
-    if (instance_field_.is_static()) continue;
-    // We should only be getting const instances, which means that we
-    // should only see final instance fields.
-    ASSERT(instance_field_.is_final());
-    tmp_string_ = instance_field_.UserVisibleName();
-    auto const label = tmp_string_.ToCString();
-    instance_field_value = inst.GetField(instance_field_);
-    fields->AddExtra(label, DartValueToSExp(instance_field_value));
-  }
-  if (fields->ExtraLength() != 0 || FLAG_verbose_flow_graph_serialization) {
-    sexp->Add(fields);
-  }
-  if (instance_class.IsGeneric()) {
-    instance_type_args_ = inst.GetTypeArguments();
-    if (auto const args = NonEmptyTypeArgumentsToSExp(instance_type_args_)) {
-      sexp->AddExtra("type_args", args);
-    }
-  }
-  if (FLAG_verbose_flow_graph_serialization) {
-    AddExtraInteger(sexp, "size", inst.InstanceSize());
-    // We know the following won't call back into InstanceToSExp because we're
-    // providing it a class.
-    if (auto const cls = DartValueToSExp(instance_class)) {
-      sexp->AddExtra("class", cls);
-    }
-  }
-  return sexp;
-}
-
-SExpression* FlowGraphSerializer::FunctionToSExp(const Function& func) {
-  if (func.IsNull()) return nullptr;
-  auto const sexp = new (zone()) SExpList(zone());
-  AddSymbol(sexp, "Function");
-  sexp->Add(CanonicalNameToSExp(func));
-  if (func.IsRecognized()) {
-    AddExtraSymbol(sexp, "recognized",
-                   MethodRecognizer::KindToCString(func.recognized_kind()));
-  }
-  if (func.is_native()) {
-    tmp_string_ = func.native_name();
-    if (!tmp_string_.IsNull()) {
-      AddExtraSymbol(sexp, "native_name", tmp_string_.ToCString());
-    }
-  }
-  if (func.kind() != UntaggedFunction::Kind::kRegularFunction ||
-      FLAG_verbose_flow_graph_serialization) {
-    AddExtraSymbol(sexp, "kind", UntaggedFunction::KindToCString(func.kind()));
-  }
-  function_type_args_ = func.type_parameters();
-  if (auto const ta_sexp = NonEmptyTypeArgumentsToSExp(function_type_args_)) {
-    sexp->AddExtra("type_args", ta_sexp);
-  }
-  return sexp;
-}
-
-SExpression* FlowGraphSerializer::ImmutableListToSExp(const Array& arr) {
-  if (arr.IsNull()) return nullptr;
-  // We should only be getting immutable lists when serializing Dart values
-  // in flow graphs.
-  ASSERT(arr.IsImmutable());
-  auto sexp = new (zone()) SExpList(zone());
-  AddSymbol(sexp, "ImmutableList");
-  // We allocate a new Object handle to use for the calls to DartValueToSExp
-  // in case any Array elements contain non-constant-pool, non-empty Arrays.
-  auto& array_elem = Object::Handle(zone());
-  for (intptr_t i = 0; i < arr.Length(); i++) {
-    array_elem = arr.At(i);
-    sexp->Add(DartValueToSExp(array_elem));
-  }
-  array_type_args_ = arr.GetTypeArguments();
-  if (auto const type_args_sexp = TypeArgumentsToSExp(array_type_args_)) {
-    sexp->AddExtra("type_args", type_args_sexp);
-  }
-  return sexp;
-}
-
-SExpression* FlowGraphSerializer::ArrayToSExp(const Array& arr) {
-  if (arr.IsNull()) return nullptr;
-  auto sexp = new (zone()) SExpList(zone());
-  AddSymbol(sexp, "Array");
-  auto& array_elem = Object::Handle(zone());
-  for (intptr_t i = 0; i < arr.Length(); i++) {
-    array_elem = arr.At(i);
-    sexp->Add(DartValueToSExp(array_elem));
-  }
-  return sexp;
-}
-
-SExpression* FlowGraphSerializer::ClosureToSExp(const Closure& c) {
-  if (c.IsNull()) return nullptr;
-  auto sexp = new (zone()) SExpList(zone());
-  AddSymbol(sexp, "Closure");
-  closure_function_ = c.function();
-  if (auto const func = FunctionToSExp(closure_function_)) {
-    sexp->Add(func);
-  }
-  closure_context_ = c.context();
-  if (auto const context = ContextToSExp(closure_context_)) {
-    sexp->AddExtra("context", context);
-  }
-  closure_type_args_ = c.function_type_arguments();
-  if (auto const type_args = NonEmptyTypeArgumentsToSExp(closure_type_args_)) {
-    sexp->AddExtra("func_type_args", type_args);
-  }
-  closure_type_args_ = c.instantiator_type_arguments();
-  if (auto const type_args = NonEmptyTypeArgumentsToSExp(closure_type_args_)) {
-    sexp->AddExtra("inst_type_args", type_args);
-  }
-  closure_type_args_ = c.delayed_type_arguments();
-  if (auto const type_args = NonEmptyTypeArgumentsToSExp(closure_type_args_)) {
-    sexp->AddExtra("delayed_type_args", type_args);
-  }
-  return sexp;
-}
-
-SExpression* FlowGraphSerializer::ContextToSExp(const Context& c) {
-  if (c.IsNull()) return nullptr;
-  auto sexp = new (zone()) SExpList(zone());
-  AddSymbol(sexp, "Context");
-  for (intptr_t i = 0; i < c.num_variables(); i++) {
-    context_elem_ = c.At(i);
-    auto const elem_sexp = DartValueToSExp(context_elem_);
-    if (elem_sexp == nullptr) return nullptr;
-    sexp->Add(elem_sexp);
-  }
-  context_parent_ = c.parent();
-  if (auto const parent_sexp = ContextToSExp(context_parent_)) {
-    sexp->AddExtra("parent", parent_sexp);
-  }
-  return sexp;
-}
-
-SExpression* FlowGraphSerializer::ObjectToSExp(const Object& dartval) {
-  if (dartval.IsNull()) {
-    return new (zone()) SExpSymbol("null");
-  }
-  if (dartval.ptr() == Object::sentinel().ptr()) {
-    return new (zone()) SExpSymbol("sentinel");
-  }
-  if (dartval.IsString()) {
-    return new (zone()) SExpString(dartval.ToCString());
-  }
-  if (dartval.IsSmi()) {
-    return new (zone()) SExpInteger(Smi::Cast(dartval).Value());
-  }
-  if (dartval.IsMint()) {
-    return new (zone()) SExpInteger(Mint::Cast(dartval).value());
-  }
-  if (dartval.IsBool()) {
-    return new (zone()) SExpBool(Bool::Cast(dartval).value());
-  }
-  if (dartval.IsDouble()) {
-    return new (zone()) SExpDouble(Double::Cast(dartval).value());
-  }
-  if (dartval.IsField()) {
-    return FieldToSExp(Field::Cast(dartval));
-  }
-  if (dartval.IsClass()) {
-    return ClassToSExp(Class::Cast(dartval));
-  }
-  if (dartval.IsTypeArguments()) {
-    return TypeArgumentsToSExp(TypeArguments::Cast(dartval));
-  }
-  if (dartval.IsCode()) {
-    return CodeToSExp(Code::Cast(dartval));
-  }
-  if (dartval.IsArray()) {
-    return ImmutableListToSExp(Array::Cast(dartval));
-  }
-  if (dartval.IsFunction()) {
-    return FunctionToSExp(Function::Cast(dartval));
-  }
-  if (dartval.IsClosure()) {
-    return ClosureToSExp(Closure::Cast(dartval));
-  }
-  if (dartval.IsAbstractType()) {
-    return AbstractTypeToSExp(AbstractType::Cast(dartval));
-  }
-  ASSERT(dartval.IsInstance());
-  return InstanceToSExp(Instance::Cast(dartval));
-}
-
-SExpression* FlowGraphSerializer::DartValueToSExp(const Object& obj) {
-  if (auto const def = flow_graph()->GetExistingConstant(obj)) {
-    ASSERT(def->IsDefinition());
-    return UseToSExp(def->AsDefinition());
-  }
-  return ObjectToSExp(obj);
-}
-
-SExpression* FlowGraphSerializer::NonEmptyTypeArgumentsToSExp(
-    const TypeArguments& ta) {
-  if (ta.IsNull() || ta.Length() == 0) return nullptr;
-  return DartValueToSExp(ta);
-}
-
-SExpression* FlowGraphSerializer::ConstantPoolToSExp(
-    const GraphEntryInstr* start) {
-  auto const initial_defs = start->initial_definitions();
-  if (initial_defs == nullptr || initial_defs->is_empty()) return nullptr;
-  auto constant_list = new (zone()) SExpList(zone());
-  AddSymbol(constant_list, "Constants");
-  for (intptr_t i = 0; i < initial_defs->length(); i++) {
-    ASSERT(initial_defs->At(i)->IsConstant());
-    auto const definition = initial_defs->At(i)->AsDefinition();
-    auto elem = new (zone()) SExpList(zone());
-    AddSymbol(elem, "def");
-    elem->Add(UseToSExp(definition));
-    // Use ObjectToSExp here, not DartValueToSExp!
-    const auto& value = definition->AsConstant()->value();
-    elem->Add(ObjectToSExp(value));
-    AddDefinitionExtraInfoToSExp(definition, elem);
-    // Only add constants to the LLVM constant pool that are actually used in
-    // the flow graph.
-    if (FLAG_populate_llvm_constant_pool && definition->HasUses()) {
-      auto const pool_len = llvm_constants_.Length();
-      llvm_index_ = Smi::New(pool_len);
-      llvm_index_ ^= llvm_constant_map_.InsertOrGetValue(value, llvm_index_);
-      if (llvm_index_.Value() == pool_len) {
-        llvm_constants_.Add(value);
-      }
-      AddExtraInteger(elem, "llvm_index", llvm_index_.Value());
-    }
-    constant_list->Add(elem);
-  }
-  return constant_list;
-}
-
-SExpression* Instruction::ToSExpression(FlowGraphSerializer* s) const {
-  auto sexp = new (s->zone()) SExpList(s->zone());
-  s->AddSymbol(sexp, DebugName());
-  AddOperandsToSExpression(sexp, s);
-  AddExtraInfoToSExpression(sexp, s);
-  return sexp;
-}
-
-SExpression* BlockEntryInstr::ToSExpression(FlowGraphSerializer* s) const {
-  auto sexp = new (s->zone()) SExpList(s->zone());
-  s->AddSymbol(sexp, "Block");
-  sexp->Add(s->BlockIdToSExp(block_id()));
-  AddOperandsToSExpression(sexp, s);
-  AddExtraInfoToSExpression(sexp, s);
-  return sexp;
-}
-
-void BlockEntryInstr::AddExtraInfoToSExpression(SExpList* sexp,
-                                                FlowGraphSerializer* s) const {
-  Instruction::AddExtraInfoToSExpression(sexp, s);
-  if (try_index() != kInvalidTryIndex) {
-    s->AddExtraInteger(sexp, "try_index", try_index());
-  }
-  if (auto const entry_tag = s->BlockEntryTag(this)) {
-    sexp->AddExtra("block_type", entry_tag);
-  }
-  if (FLAG_verbose_flow_graph_serialization) {
-    if (PredecessorCount() > 0) {
-      auto const preds = new (s->zone()) SExpList(s->zone());
-      for (intptr_t i = 0; i < PredecessorCount(); i++) {
-        preds->Add(s->BlockIdToSExp(PredecessorAt(i)->block_id()));
-      }
-      sexp->AddExtra("predecessors", preds);
-    }
-  }
-}
-
-void BlockEntryInstr::AddOperandsToSExpression(SExpList* sexp,
-                                               FlowGraphSerializer* s) const {
-  for (const auto* inst = next_; inst != nullptr; inst = inst->next_) {
-    sexp->Add(inst->ToSExpression(s));
-  }
-}
-
-void JoinEntryInstr::AddOperandsToSExpression(SExpList* sexp,
-                                              FlowGraphSerializer* s) const {
-  if (auto phi_list = phis()) {
-    for (intptr_t i = 0; i < phi_list->length(); i++) {
-      sexp->Add(phi_list->At(i)->ToSExpression(s));
-    }
-  }
-  BlockEntryInstr::AddOperandsToSExpression(sexp, s);
-}
-
-void Instruction::AddOperandsToSExpression(SExpList* sexp,
-                                           FlowGraphSerializer* s) const {
-  for (intptr_t i = 0; i < InputCount(); ++i) {
-    if (InputAt(i) == nullptr) continue;
-    sexp->Add(InputAt(i)->ToSExpression(s));
-  }
-}
-
-void Instruction::AddExtraInfoToSExpression(SExpList* sexp,
-                                            FlowGraphSerializer* s) const {
-  if (GetDeoptId() != DeoptId::kNone) {
-    s->AddExtraInteger(sexp, "deopt_id", GetDeoptId());
-  }
-  if (env() != nullptr) {
-    sexp->AddExtra("env", env()->ToSExpression(s));
-  }
-  if (!token_pos().IsNoSource()) {
-    s->AddExtraInteger(sexp, "token_pos", token_pos().Serialize());
-  }
-  if (has_inlining_id()) {
-    s->AddExtraInteger(sexp, "inlining_id", inlining_id());
-  }
-}
-
-SExpression* Range::ToSExpression(FlowGraphSerializer* s) {
-  auto const sexp = new (s->zone()) SExpList(s->zone());
-  s->AddSymbol(sexp, "Range");
-  sexp->Add(min_.ToSExpression(s));
-  if (!max_.Equals(min_)) sexp->Add(max_.ToSExpression(s));
-  return sexp;
-}
-
-SExpression* RangeBoundary::ToSExpression(FlowGraphSerializer* s) {
-  switch (kind_) {
-    case kSymbol: {
-      auto const sexp = new (s->zone()) SExpList(s->zone());
-      sexp->Add(s->UseToSExp(symbol()));
-      if (offset() != 0) {
-        s->AddExtraInteger(sexp, "offset", offset());
-      }
-      return sexp;
-    }
-    case kConstant:
-      return new (s->zone()) SExpInteger(value_);
-    default:
-      return new (s->zone()) SExpSymbol(RangeBoundary::KindToCString(kind_));
-  }
-}
-
-bool FlowGraphSerializer::HasDefinitionExtraInfo(const Definition* def) {
-  return ShouldSerializeType(def->type_) || def->range() != nullptr;
-}
-
-void FlowGraphSerializer::AddDefinitionExtraInfoToSExp(const Definition* def,
-                                                       SExpList* sexp) {
-  // Type() isn't a const method as it can cause changes to the type_
-  // field, so access type_ directly instead.
-  if (ShouldSerializeType(def->type_)) {
-    sexp->AddExtra("type", def->type_->ToSExpression(this));
-  }
-  if (def->range() != nullptr) {
-    sexp->AddExtra("range", def->range()->ToSExpression(this));
-  }
-}
-
-SExpression* Definition::ToSExpression(FlowGraphSerializer* s) const {
-  // If we don't have a temp index, then this is a Definition that has no
-  // usable result.
-  const bool binds_name = HasSSATemp() || HasTemp();
-  // Don't serialize non-binding definitions as definitions unless we either
-  // have Definition-specific extra info or we're in verbose mode.
-  if (!binds_name && !FLAG_verbose_flow_graph_serialization &&
-      !s->HasDefinitionExtraInfo(this)) {
-    return Instruction::ToSExpression(s);
-  }
-  auto sexp = new (s->zone()) SExpList(s->zone());
-  s->AddSymbol(sexp, "def");
-  if (binds_name) {
-    sexp->Add(s->UseToSExp(this));
-  } else {
-    // Since there is Definition-specific extra info to serialize, we use "_"
-    // as the bound name, which lets the deserializer know the result is unused.
-    s->AddSymbol(sexp, "_");
-  }
-  // Add only Definition-specific extra info to this form. Any extra info
-  // that is Instruction-specific or specific to the actual instruction type is
-  // added to the nested instruction form.
-  s->AddDefinitionExtraInfoToSExp(this, sexp);
-  sexp->Add(Instruction::ToSExpression(s));
-  return sexp;
-}
-
-void AssertAssignableInstr::AddExtraInfoToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  Instruction::AddExtraInfoToSExpression(sexp, s);
-  sexp->AddExtra("name", s->DartValueToSExp(dst_name()));
-}
-
-void ConstantInstr::AddOperandsToSExpression(SExpList* sexp,
-                                             FlowGraphSerializer* s) const {
-  sexp->Add(s->DartValueToSExp(value()));
-}
-
-void BranchInstr::AddOperandsToSExpression(SExpList* sexp,
-                                           FlowGraphSerializer* s) const {
-  sexp->Add(comparison()->ToSExpression(s));
-  sexp->Add(s->BlockIdToSExp(true_successor()->block_id()));
-  sexp->Add(s->BlockIdToSExp(false_successor()->block_id()));
-}
-
-void ParameterInstr::AddOperandsToSExpression(SExpList* sexp,
-                                              FlowGraphSerializer* s) const {
-  s->AddInteger(sexp, index());
-  s->AddExtraInteger(sexp, "param_offset", param_offset());
-  s->AddExtraSymbol(sexp, "representation",
-                    Location::RepresentationToCString(representation()));
-}
-
-void SpecialParameterInstr::AddOperandsToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  ASSERT(kind() < SpecialParameterInstr::kNumKinds);
-  s->AddSymbol(sexp, KindToCString(kind()));
-}
-
-SExpression* FlowGraphSerializer::LocalVariableToSExp(const LocalVariable& v) {
-  auto const sexp = new (zone()) SExpList(zone());
-  AddSymbol(sexp, "LocalVariable");
-  if (!v.name().IsNull()) {
-    AddSymbol(sexp, v.name().ToCString());
-  }
-  if (v.index().IsValid()) {
-    AddExtraInteger(sexp, "index", v.index().value());
-  }
-  return sexp;
-}
-
-void LoadLocalInstr::AddOperandsToSExpression(SExpList* sexp,
-                                              FlowGraphSerializer* s) const {
-  sexp->Add(s->LocalVariableToSExp(local()));
-}
-
-void StoreLocalInstr::AddOperandsToSExpression(SExpList* sexp,
-                                               FlowGraphSerializer* s) const {
-  sexp->Add(s->LocalVariableToSExp(local()));
-}
-
-SExpression* FlowGraphSerializer::SlotToSExp(const Slot& slot) {
-  auto sexp = new (zone()) SExpList(zone());
-  AddSymbol(sexp, "Slot");
-  AddInteger(sexp, slot.offset_in_bytes());
-  AddExtraSymbol(sexp, "kind", Slot::KindToCString(slot.kind()));
-  if (slot.IsDartField()) {
-    sexp->AddExtra("field", DartValueToSExp(slot.field()));
-  }
-  return sexp;
-}
-
-void LoadFieldInstr::AddOperandsToSExpression(SExpList* sexp,
-                                              FlowGraphSerializer* s) const {
-  sexp->Add(instance()->ToSExpression(s));
-  sexp->Add(s->SlotToSExp(slot()));
-}
-
-void LoadFieldInstr::AddExtraInfoToSExpression(SExpList* sexp,
-                                               FlowGraphSerializer* s) const {
-  Instruction::AddExtraInfoToSExpression(sexp, s);
-  if (calls_initializer() || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraBool(sexp, "calls_initializer", calls_initializer());
-  }
-}
-
-void StoreInstanceFieldInstr::AddOperandsToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  sexp->Add(instance()->ToSExpression(s));
-  sexp->Add(s->SlotToSExp(slot()));
-  sexp->Add(value()->ToSExpression(s));
-}
-
-void StoreInstanceFieldInstr::AddExtraInfoToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  Instruction::AddExtraInfoToSExpression(sexp, s);
-  if (is_initialization_ || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraBool(sexp, "is_init", is_initialization_);
-  }
-  if (emit_store_barrier_ != kNoStoreBarrier ||
-      FLAG_verbose_flow_graph_serialization) {
-    // Make sure that we aren't seeing a new value added to the StoreBarrierType
-    // enum that isn't handled by the serializer.
-    ASSERT(emit_store_barrier_ == kNoStoreBarrier ||
-           emit_store_barrier_ == kEmitStoreBarrier);
-    s->AddExtraBool(sexp, "emit_barrier",
-                    emit_store_barrier_ != kNoStoreBarrier);
-  }
-}
-
-void LoadIndexedUnsafeInstr::AddExtraInfoToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  Instruction::AddExtraInfoToSExpression(sexp, s);
-  if (offset() > 0 || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraInteger(sexp, "offset", offset());
-  }
-}
-
-void StoreIndexedUnsafeInstr::AddExtraInfoToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  Instruction::AddExtraInfoToSExpression(sexp, s);
-  if (offset() > 0 || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraInteger(sexp, "offset", offset());
-  }
-}
-
-void ComparisonInstr::AddOperandsToSExpression(SExpList* sexp,
-                                               FlowGraphSerializer* s) const {
-  s->AddSymbol(sexp, Token::Str(kind()));
-  Instruction::AddOperandsToSExpression(sexp, s);
-}
-
-void StrictCompareInstr::AddExtraInfoToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  Instruction::AddExtraInfoToSExpression(sexp, s);
-  if (needs_number_check_ || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraBool(sexp, "needs_check", needs_number_check_);
-  }
-}
-
-void DoubleTestOpInstr::AddOperandsToSExpression(SExpList* sexp,
-                                                 FlowGraphSerializer* s) const {
-  const bool negated = kind() != Token::kEQ;
-  switch (op_kind()) {
-    case MethodRecognizer::kDouble_getIsNaN:
-      s->AddSymbol(sexp, negated ? "IsNotNaN" : "IsNaN");
-      break;
-    case MethodRecognizer::kDouble_getIsInfinite:
-      s->AddSymbol(sexp, negated ? "IsNotInfinite" : "IsInfinite");
-      break;
-    default:
-      UNREACHABLE();
-  }
-  sexp->Add(value()->ToSExpression(s));
-}
-
-void GotoInstr::AddOperandsToSExpression(SExpList* sexp,
-                                         FlowGraphSerializer* s) const {
-  sexp->Add(s->BlockIdToSExp(successor()->block_id()));
-}
-
-void DebugStepCheckInstr::AddExtraInfoToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  Instruction::AddExtraInfoToSExpression(sexp, s);
-  if (stub_kind_ != UntaggedPcDescriptors::kAnyKind ||
-      FLAG_verbose_flow_graph_serialization) {
-    auto const stub_kind_name =
-        UntaggedPcDescriptors::KindToCString(stub_kind_);
-    ASSERT(stub_kind_name != nullptr);
-    s->AddExtraSymbol(sexp, "stub_kind", stub_kind_name);
-  }
-}
-
-SExpression* FlowGraphSerializer::ICDataToSExp(const ICData* ic_data) {
-  auto const sexp = new (zone()) SExpList(zone());
-  AddSymbol(sexp, "ICData");
-
-  if (ic_data->is_tracking_exactness()) {
-    ic_data_type_ = ic_data->receivers_static_type();
-    sexp->AddExtra("receivers_static_type", AbstractTypeToSExp(ic_data_type_));
-  }
-
-  if (ic_data->is_megamorphic() || FLAG_verbose_flow_graph_serialization) {
-    AddExtraBool(sexp, "is_megamorphic", ic_data->is_megamorphic());
-  }
-
-  auto const num_checks = ic_data->NumberOfChecks();
-  GrowableArray<intptr_t> class_ids(zone(), 2);
-  for (intptr_t i = 0; i < num_checks; i++) {
-    auto const entry = new (zone()) SExpList(zone());
-
-    auto const count = ic_data->GetCountAt(i);
-    if (count > 0 || FLAG_verbose_flow_graph_serialization) {
-      AddExtraInteger(entry, "count", count);
-    }
-
-    class_ids.Clear();
-    ic_data->GetCheckAt(i, &class_ids, &ic_data_target_);
-    entry->AddExtra("target", DartValueToSExp(ic_data_target_));
-    for (auto const cid : class_ids) {
-      entry->Add(new (zone()) SExpInteger(cid));
-    }
-
-    sexp->Add(entry);
-  }
-
-  if (FLAG_verbose_flow_graph_serialization) {
-    AddExtraSymbol(sexp, "rebind_rule",
-                   ICData::RebindRuleToCString(ic_data->rebind_rule()));
-    tmp_string_ = ic_data->target_name();
-    AddExtraString(sexp, "target_name", tmp_string_.ToCString());
-    ic_data_target_ = ic_data->Owner();
-    sexp->AddExtra("owner", DartValueToSExp(ic_data_target_));
-    AddExtraInteger(sexp, "num_args_tested", ic_data->NumArgsTested());
-    auto& args_desc = Array::Handle(zone(), ic_data->arguments_descriptor());
-    sexp->AddExtra("arguments_descriptor", DartValueToSExp(args_desc));
-  }
-
-  return sexp;
-}
-
-void TailCallInstr::AddOperandsToSExpression(SExpList* sexp,
-                                             FlowGraphSerializer* s) const {
-  if (auto const code = s->DartValueToSExp(code_)) {
-    sexp->Add(code);
-  }
-  Instruction::AddOperandsToSExpression(sexp, s);
-}
-
-void NativeCallInstr::AddOperandsToSExpression(SExpList* sexp,
-                                               FlowGraphSerializer* s) const {
-  Instruction::AddOperandsToSExpression(sexp, s);
-}
-
-void NativeCallInstr::AddExtraInfoToSExpression(SExpList* sexp,
-                                                FlowGraphSerializer* s) const {
-  TemplateDartCall<0>::AddExtraInfoToSExpression(sexp, s);
-  if (auto const func = s->DartValueToSExp(function())) {
-    sexp->AddExtra("function", func);
-  }
-  if (!native_name().IsNull()) {
-    s->AddExtraString(sexp, "name", native_name().ToCString());
-  }
-  if (link_lazily() || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraBool(sexp, "link_lazily", link_lazily());
-  }
-}
-
-template <intptr_t kExtraInputs>
-void TemplateDartCall<kExtraInputs>::AddExtraInfoToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  Instruction::AddExtraInfoToSExpression(sexp, s);
-  if (type_args_len() > 0 || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraInteger(sexp, "type_args_len", type_args_len());
-  }
-  s->AddExtraInteger(sexp, "args_len", ArgumentCountWithoutTypeArgs());
-
-  const auto& arg_names = argument_names();
-  if (!arg_names.IsNull()) {
-    auto arg_names_sexp = new (s->zone()) SExpList(s->zone());
-    auto& str = String::Handle(s->zone());
-    for (intptr_t i = 0; i < arg_names.Length(); i++) {
-      str = String::RawCast(arg_names.At(i));
-      arg_names_sexp->Add(s->ObjectToSExp(str));
-    }
-    sexp->AddExtra("arg_names", arg_names_sexp);
-  }
-
-  ASSERT(!HasPushArguments());
-}
-
-void ClosureCallInstr::AddExtraInfoToSExpression(SExpList* sexp,
-                                                 FlowGraphSerializer* s) const {
-  // For now, just here to ensure TemplateDartCall<1>::AddExtraInfoToSExpression
-  // gets instantiated.
-  TemplateDartCall<1>::AddExtraInfoToSExpression(sexp, s);
-}
-
-void StaticCallInstr::AddOperandsToSExpression(SExpList* sexp,
-                                               FlowGraphSerializer* s) const {
-  Instruction::AddOperandsToSExpression(sexp, s);
-}
-
-void StaticCallInstr::AddExtraInfoToSExpression(SExpList* sexp,
-                                                FlowGraphSerializer* s) const {
-  TemplateDartCall<0>::AddExtraInfoToSExpression(sexp, s);
-
-  if (auto const func = s->DartValueToSExp(function())) {
-    sexp->AddExtra("function", func);
-  }
-
-  if (HasICData()) {
-    sexp->AddExtra("ic_data", s->ICDataToSExp(ic_data()));
-  } else if (CallCount() > 0 || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraInteger(sexp, "call_count", CallCount());
-  }
-
-  if (rebind_rule_ != ICData::kStatic ||
-      FLAG_verbose_flow_graph_serialization) {
-    auto const str = ICData::RebindRuleToCString(rebind_rule_);
-    ASSERT(str != nullptr);
-    s->AddExtraSymbol(sexp, "rebind_rule", str);
-  }
-
-  if (ShouldSerializeType(result_type())) {
-    sexp->AddExtra("result_type", result_type()->ToSExpression(s));
-  }
-
-  if (entry_kind() != Code::EntryKind::kNormal ||
-      FLAG_verbose_flow_graph_serialization) {
-    auto const kind_str = Code::EntryKindToCString(entry_kind());
-    s->AddExtraSymbol(sexp, "entry_kind", kind_str);
-  }
-}
-
-void InstanceCallBaseInstr::AddOperandsToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  Instruction::AddOperandsToSExpression(sexp, s);
-}
-
-void InstanceCallBaseInstr::AddExtraInfoToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  TemplateDartCall<0>::AddExtraInfoToSExpression(sexp, s);
-
-  if (auto const target = s->DartValueToSExp(interface_target())) {
-    sexp->AddExtra("interface_target", target);
-  }
-
-  if (auto const target = s->DartValueToSExp(tearoff_interface_target())) {
-    sexp->AddExtra("tearoff_interface_target", target);
-  }
-
-  if (HasICData()) {
-    sexp->AddExtra("ic_data", s->ICDataToSExp(ic_data()));
-  }
-
-  if (function_name().IsNull()) {
-    if (!interface_target().IsNull() || !tearoff_interface_target().IsNull()) {
-      s->AddExtraSymbol(sexp, "function_name", "null");
-    }
-  } else {
-    if (interface_target().IsNull() ||
-        (function_name().ptr() != interface_target().name() &&
-         function_name().ptr() != tearoff_interface_target().name())) {
-      s->AddExtraString(sexp, "function_name", function_name().ToCString());
-    }
-  }
-
-  if (token_kind() != Token::kILLEGAL) {
-    s->AddExtraSymbol(sexp, "token_kind", Token::Str(token_kind()));
-  }
-
-  if (ShouldSerializeType(result_type())) {
-    sexp->AddExtra("result_type", result_type()->ToSExpression(s));
-  }
-
-  if (entry_kind() != Code::EntryKind::kNormal ||
-      FLAG_verbose_flow_graph_serialization) {
-    auto const kind_str = Code::EntryKindToCString(entry_kind());
-    s->AddExtraSymbol(sexp, "entry_kind", kind_str);
-  }
-}
-
-void InstanceCallInstr::AddExtraInfoToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  InstanceCallBaseInstr::AddExtraInfoToSExpression(sexp, s);
-
-  if (checked_argument_count() > 0 || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraInteger(sexp, "checked_arg_count", checked_argument_count());
-  }
-}
-
-void PolymorphicInstanceCallInstr::AddExtraInfoToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  InstanceCallBaseInstr::AddExtraInfoToSExpression(sexp, s);
-
-  if (targets().length() > 0 || FLAG_verbose_flow_graph_serialization) {
-    auto elem_list = new (s->zone()) SExpList(s->zone());
-    for (intptr_t i = 0; i < targets().length(); i++) {
-      auto elem = new (s->zone()) SExpList(s->zone());
-      const TargetInfo* ti = targets().TargetAt(i);
-      if (ti->cid_start == ti->cid_end) {
-        s->AddInteger(elem, ti->cid_start);
-      } else {
-        auto range = new (s->zone()) SExpList(s->zone());
-        s->AddInteger(range, ti->cid_start);
-        s->AddInteger(range, ti->cid_end);
-        elem->Add(range);
-      }
-      if (auto const target = s->DartValueToSExp(*ti->target)) {
-        elem->Add(target);
-      }
-      elem_list->Add(elem);
-    }
-    sexp->AddExtra("targets", elem_list);
-  }
-}
-
-void AllocateObjectInstr::AddOperandsToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  if (auto const sexp_cls = s->DartValueToSExp(cls())) {
-    sexp->Add(sexp_cls);
-  }
-  if (type_arguments() != nullptr) {
-    sexp->Add(type_arguments()->ToSExpression(s));
-  }
-}
-
-void AllocateObjectInstr::AddExtraInfoToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  Instruction::AddExtraInfoToSExpression(sexp, s);
-  s->AddExtraInteger(sexp, "size", cls().target_instance_size());
-  if (auto const closure = s->DartValueToSExp(closure_function())) {
-    sexp->AddExtra("closure_function", closure);
-  }
-  if (!Identity().IsUnknown() || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraSymbol(sexp, "identity", Identity().ToCString());
-  }
-}
-
-void BinaryIntegerOpInstr::AddOperandsToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  s->AddSymbol(sexp, Token::Str(op_kind()));
-  sexp->Add(left()->ToSExpression(s));
-  sexp->Add(right()->ToSExpression(s));
-}
-
-void CheckedSmiOpInstr::AddOperandsToSExpression(SExpList* sexp,
-                                                 FlowGraphSerializer* s) const {
-  s->AddSymbol(sexp, Token::Str(op_kind()));
-  sexp->Add(left()->ToSExpression(s));
-  sexp->Add(right()->ToSExpression(s));
-}
-
-// clang-format off
-static const char* simd_op_kind_string[] = {
-#define CASE(Arity, Mask, Name, ...) #Name,
-  SIMD_OP_LIST(CASE, CASE)
-#undef CASE
-  "IllegalSimdOp",
-};
-// clang-format on
-
-void SimdOpInstr::AddOperandsToSExpression(SExpList* sexp,
-                                           FlowGraphSerializer* s) const {
-  s->AddSymbol(sexp, simd_op_kind_string[kind()]);
-  Instruction::AddOperandsToSExpression(sexp, s);
-}
-
-void SimdOpInstr::AddExtraInfoToSExpression(SExpList* sexp,
-                                            FlowGraphSerializer* s) const {
-  Instruction::AddExtraInfoToSExpression(sexp, s);
-  if (HasMask()) {
-    s->AddExtraInteger(sexp, "mask", mask());
-  }
-}
-
-void LoadIndexedInstr::AddExtraInfoToSExpression(SExpList* sexp,
-                                                 FlowGraphSerializer* s) const {
-  Instruction::AddExtraInfoToSExpression(sexp, s);
-  if (aligned() || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraBool(sexp, "aligned", aligned());
-  }
-  if (index_scale() > 1 || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraInteger(sexp, "scale", index_scale());
-  }
-  if (class_id() != kDynamicCid || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraInteger(sexp, "cid", class_id());
-  }
-}
-
-void StoreIndexedInstr::AddExtraInfoToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  Instruction::AddExtraInfoToSExpression(sexp, s);
-  if (aligned() || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraBool(sexp, "aligned", aligned());
-  }
-  if (index_scale() > 1 || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraInteger(sexp, "scale", index_scale());
-  }
-  if (class_id() != kDynamicCid || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraInteger(sexp, "cid", class_id());
-  }
-}
-
-void CheckStackOverflowInstr::AddExtraInfoToSExpression(
-    SExpList* sexp,
-    FlowGraphSerializer* s) const {
-  Instruction::AddExtraInfoToSExpression(sexp, s);
-  if (stack_depth() > 0 || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraInteger(sexp, "stack_depth", stack_depth());
-  }
-  if (in_loop() || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraInteger(sexp, "loop_depth", loop_depth());
-  }
-  if (kind_ != kOsrAndPreemption) {
-    ASSERT(kind_ == kOsrOnly);
-    s->AddExtraSymbol(sexp, "kind", "OsrOnly");
-  }
-}
-
-void CheckNullInstr::AddExtraInfoToSExpression(SExpList* sexp,
-                                               FlowGraphSerializer* s) const {
-  Instruction::AddExtraInfoToSExpression(sexp, s);
-  if (!function_name_.IsNull()) {
-    s->AddExtraString(sexp, "function_name", function_name_.ToCString());
-  }
-}
-
-SExpression* Value::ToSExpression(FlowGraphSerializer* s) const {
-  auto name = s->UseToSExp(definition());
-  // If we're not serializing types or there is no reaching type for this use,
-  // just serialize the use as the bound name.
-  if (!ShouldSerializeType(reaching_type_)) return name;
-
-  auto sexp = new (s->zone()) SExpList(s->zone());
-  s->AddSymbol(sexp, "value");
-  sexp->Add(name);
-  // If there is no owner for the type, then serialize the type in full.
-  // Otherwise the owner should be the definition, so we'll inherit the type
-  // from it. (That is, (value v<X>) with no explicit type info means the
-  // reaching type comes from the definition of v<X>.) We'll serialize an
-  // "inherit_type" extra info field to make this explicit when in verbose mode.
-  if (reaching_type_->owner() == nullptr) {
-    sexp->AddExtra("type", reaching_type_->ToSExpression(s));
-  } else {
-    ASSERT(reaching_type_->owner() == definition());
-  }
-  if (FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraBool(sexp, "inherit_type",
-                    reaching_type_->owner() == definition());
-  }
-  return sexp;
-}
-
-SExpression* CompileType::ToSExpression(FlowGraphSerializer* s) const {
-  ASSERT(FLAG_verbose_flow_graph_serialization ||
-         FLAG_serialize_flow_graph_types);
-
-  auto sexp = new (s->zone()) SExpList(s->zone());
-  s->AddSymbol(sexp, "CompileType");
-  AddExtraInfoToSExpression(sexp, s);
-  return sexp;
-}
-
-void CompileType::AddExtraInfoToSExpression(SExpList* sexp,
-                                            FlowGraphSerializer* s) const {
-  if (cid_ != kIllegalCid || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraInteger(sexp, "cid", cid_);
-  }
-  // TODO(sstrickl): Currently we only print out nullable if it's false
-  // (or during verbose printing). Switch this when NNBD is the standard.
-  if (!is_nullable() || FLAG_verbose_flow_graph_serialization) {
-    s->AddExtraBool(sexp, "nullable", is_nullable());
-  }
-  if (type_ != nullptr) {
-    sexp->AddExtra("type", s->DartValueToSExp(*type_));
-  }
-}
-
-SExpression* Environment::ToSExpression(FlowGraphSerializer* s) const {
-  auto sexp = new (s->zone()) SExpList(s->zone());
-  for (intptr_t i = 0; i < values_.length(); ++i) {
-    ASSERT(!values_[i]->definition()->IsPushArgument());
-    sexp->Add(values_[i]->ToSExpression(s));
-    // TODO(sstrickl): This currently assumes that there are no locations in the
-    // environment (e.g. before register allocation). If we ever want to print
-    // out environments on steps after AllocateRegisters, we'll need to handle
-    // locations as well.
-    ASSERT(locations_ == nullptr || locations_[i].IsInvalid());
-  }
-  if (outer_ != NULL) {
-    auto outer_sexp = outer_->ToSExpression(s)->AsList();
-    if (outer_->deopt_id_ != DeoptId::kNone) {
-      s->AddExtraInteger(outer_sexp, "deopt_id", outer_->deopt_id_);
-    }
-    sexp->AddExtra("outer", outer_sexp);
-  }
-  return sexp;
-}
-
-}  // namespace dart
diff --git a/runtime/vm/compiler/backend/il_serializer.h b/runtime/vm/compiler/backend/il_serializer.h
deleted file mode 100644
index fda5731..0000000
--- a/runtime/vm/compiler/backend/il_serializer.h
+++ /dev/null
@@ -1,198 +0,0 @@
-// Copyright (c) 2019, 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.
-
-#ifndef RUNTIME_VM_COMPILER_BACKEND_IL_SERIALIZER_H_
-#define RUNTIME_VM_COMPILER_BACKEND_IL_SERIALIZER_H_
-
-#if defined(DART_PRECOMPILED_RUNTIME)
-#error "AOT runtime should not use compiler sources (including header files)"
-#endif  // defined(DART_PRECOMPILED_RUNTIME)
-
-#include "platform/assert.h"
-#include "platform/text_buffer.h"
-
-#include "vm/allocation.h"
-#include "vm/compiler/backend/flow_graph.h"
-#include "vm/compiler/backend/il.h"
-#include "vm/compiler/backend/sexpression.h"
-#include "vm/hash_table.h"
-#include "vm/object.h"
-#include "vm/zone.h"
-
-namespace dart {
-
-// Flow graph serialization.
-class FlowGraphSerializer : ValueObject {
- public:
-#define FOR_EACH_BLOCK_ENTRY_KIND(M)                                           \
-  M(Target)                                                                    \
-  M(Join)                                                                      \
-  M(Graph)                                                                     \
-  M(Normal)                                                                    \
-  M(Unchecked)                                                                 \
-  M(OSR)                                                                       \
-  M(Catch)                                                                     \
-  M(Indirect)
-
-  enum BlockEntryKind {
-#define KIND_DECL(name) k##name,
-    FOR_EACH_BLOCK_ENTRY_KIND(KIND_DECL)
-#undef KIND_DECL
-    // clang-format off
-    kNumEntryKinds,
-    kInvalid = -1,
-    // clang-format on
-  };
-
-  // Special case: returns kTarget for a nullptr input.
-  static BlockEntryKind BlockEntryTagToKind(SExpSymbol* tag);
-  SExpSymbol* BlockEntryKindToTag(BlockEntryKind k);
-  static bool BlockEntryKindHasInitialDefs(BlockEntryKind kind);
-
-  static void SerializeToBuffer(Zone* zone,
-                                const FlowGraph* flow_graph,
-                                BaseTextBuffer* buffer);
-  static SExpression* SerializeToSExp(Zone* zone, const FlowGraph* flow_graph);
-
-  const FlowGraph* flow_graph() const { return flow_graph_; }
-  Zone* zone() const { return zone_; }
-
-  SExpression* FlowGraphToSExp();
-
-  SExpSymbol* BlockEntryTag(const BlockEntryInstr* entry);
-  SExpression* BlockIdToSExp(intptr_t block_id);
-  SExpression* CanonicalNameToSExp(const Object& obj);
-  SExpression* UseToSExp(const Definition* definition);
-
-  // Helper method for creating canonical names.
-  void SerializeCanonicalName(BaseTextBuffer* b, const Object& obj);
-
-  // Methods for serializing Dart values. If the argument
-  // value is the null object, the null pointer is returned.
-  SExpression* AbstractTypeToSExp(const AbstractType& typ);
-  SExpression* ArrayToSExp(const Array& arr);
-  SExpression* ImmutableListToSExp(const Array& arr);
-  SExpression* ClassToSExp(const Class& cls);
-  SExpression* ClosureToSExp(const Closure& c);
-  SExpression* ContextToSExp(const Context& c);
-  SExpression* CodeToSExp(const Code& c);
-  SExpression* FieldToSExp(const Field& f);
-  SExpression* FunctionToSExp(const Function& f);
-  SExpression* InstanceToSExp(const Instance& obj);
-  SExpression* TypeArgumentsToSExp(const TypeArguments& ta);
-
-  // A method for serializing a Dart value of arbitrary type. Unlike the
-  // type-specific methods, this returns the symbol "null" for the null object.
-  SExpression* ObjectToSExp(const Object& obj);
-
-  // A wrapper method for ObjectToSExp that first checks and sees if
-  // the provided value is in the constant pool. If it is, then it
-  // returns a reference to the constant definition via UseToSExp.
-  SExpression* DartValueToSExp(const Object& obj);
-
-  // A wrapper method for TypeArgumentsToSExp that also returns nullptr if the
-  // type arguments are empty and checks against the constant pool.
-  SExpression* NonEmptyTypeArgumentsToSExp(const TypeArguments& ta);
-
-  // Methods for serializing IL-specific values.
-  SExpression* LocalVariableToSExp(const LocalVariable& v);
-  SExpression* SlotToSExp(const Slot& s);
-  SExpression* ICDataToSExp(const ICData* ic_data);
-
-  // Helper methods for adding Definition-specific extra info.
-  bool HasDefinitionExtraInfo(const Definition* def);
-  void AddDefinitionExtraInfoToSExp(const Definition* def, SExpList* sexp);
-
-  // Helper methods for adding atoms to S-expression lists
-  void AddBool(SExpList* sexp, bool b);
-  void AddInteger(SExpList* sexp, intptr_t i);
-  void AddString(SExpList* sexp, const char* cstr);
-  void AddSymbol(SExpList* sexp, const char* cstr);
-  void AddExtraBool(SExpList* sexp, const char* label, bool b);
-  void AddExtraInteger(SExpList* sexp, const char* label, intptr_t i);
-  void AddExtraString(SExpList* sexp, const char* label, const char* cstr);
-  void AddExtraSymbol(SExpList* sexp, const char* label, const char* cstr);
-
- private:
-  friend class Precompiler;  // For LLVMConstantsMap.
-
-  FlowGraphSerializer(Zone* zone, const FlowGraph* flow_graph);
-  ~FlowGraphSerializer();
-
-  static const char* const initial_indent;
-
-  // Helper methods for the function level that are not used by any
-  // instruction serialization methods.
-  SExpression* FunctionEntryToSExp(const BlockEntryInstr* entry);
-  SExpression* EntriesToSExp(const GraphEntryInstr* start);
-  SExpression* ConstantPoolToSExp(const GraphEntryInstr* start);
-
-  const FlowGraph* const flow_graph_;
-  Zone* const zone_;
-  ObjectStore* const object_store_;
-
-  // A map of currently open (being serialized) recursive types. We use this
-  // to determine whether to serialize the referred types in TypeRefs.
-  IntMap<const AbstractType*> open_recursive_types_;
-
-  // Used for --populate-llvm-constant-pool in ConstantPoolToSExp.
-  class LLVMPoolMapKeyEqualsTraits : public AllStatic {
-   public:
-    static const char* Name() { return "LLVMPoolMapKeyEqualsTraits"; }
-    static bool ReportStats() { return false; }
-
-    static bool IsMatch(const Object& a, const Object& b) {
-      return a.ptr() == b.ptr();
-    }
-    static uword Hash(const Object& obj) {
-      if (obj.IsSmi()) return static_cast<uword>(obj.ptr());
-      if (obj.IsInstance()) return Instance::Cast(obj).CanonicalizeHash();
-      return obj.GetClassId();
-    }
-  };
-  typedef UnorderedHashMap<LLVMPoolMapKeyEqualsTraits> LLVMPoolMap;
-
-  GrowableObjectArray& llvm_constants_;
-  GrowableObjectArray& llvm_functions_;
-  LLVMPoolMap llvm_constant_map_;
-  Smi& llvm_index_;
-
-  // Handles used across functions, where the contained value is used
-  // immediately and does not need to live across calls to other serializer
-  // functions.
-  String& tmp_string_;
-
-  // Handles for use within a single function in the following cases:
-  //
-  // * The function is guaranteed to not be re-entered during execution.
-  // * The contained value is not live across any possible re-entry.
-  //
-  // Generally, the most likely source of possible re-entry is calling
-  // DartValueToSExp with a sub-element of type Object, but any call to a
-  // FlowGraphSerializer method that may eventually enter one of the methods
-  // listed below should be examined with care.
-  TypeArguments& array_type_args_;     // ArrayToSExp
-  Context& closure_context_;           // ClosureToSExp
-  Function& closure_function_;         // ClosureToSExp
-  TypeArguments& closure_type_args_;   // ClosureToSExp
-  Object& code_owner_;                 // CodeToSExp
-  Context& context_parent_;            // ContextToSExp
-  Object& context_elem_;               // ContextToSExp
-  TypeArguments& function_type_args_;  // FunctionToSExp
-  Function& ic_data_target_;           // ICDataToSExp
-  AbstractType& ic_data_type_;         // ICDataToSExp
-  Field& instance_field_;              // InstanceToSExp
-  TypeArguments& instance_type_args_;  // InstanceToSExp
-  Library& serialize_library_;         // SerializeCanonicalName
-  Class& serialize_owner_;             // SerializeCanonicalName
-  Function& serialize_parent_;         // SerializeCanonicalName
-  AbstractType& type_arguments_elem_;  // TypeArgumentsToSExp
-  Class& type_class_;                  // AbstractTypeToSExp
-  FunctionType& type_signature_;       // AbstractTypeToSExp
-  AbstractType& type_ref_type_;        // AbstractTypeToSExp
-};
-
-}  // namespace dart
-
-#endif  // RUNTIME_VM_COMPILER_BACKEND_IL_SERIALIZER_H_
diff --git a/runtime/vm/compiler/backend/range_analysis.h b/runtime/vm/compiler/backend/range_analysis.h
index 7491def..ab21d74 100644
--- a/runtime/vm/compiler/backend/range_analysis.h
+++ b/runtime/vm/compiler/backend/range_analysis.h
@@ -14,9 +14,6 @@
 
 namespace dart {
 
-class SExpression;
-class FlowGraphSerializer;
-
 class RangeBoundary : public ValueObject {
  public:
 #define FOR_EACH_RANGE_BOUNDARY_KIND(V)                                        \
@@ -246,7 +243,6 @@
 
   void PrintTo(BaseTextBuffer* f) const;
   const char* ToCString() const;
-  SExpression* ToSExpression(FlowGraphSerializer* s);
 
   static RangeBoundary Add(const RangeBoundary& a,
                            const RangeBoundary& b,
@@ -347,7 +343,6 @@
 
   void PrintTo(BaseTextBuffer* f) const;
   static const char* ToCString(const Range* range);
-  SExpression* ToSExpression(FlowGraphSerializer* s);
 
   bool Equals(const Range* other) {
     ASSERT(min_.IsUnknown() == max_.IsUnknown());
diff --git a/runtime/vm/compiler/backend/sexpression.cc b/runtime/vm/compiler/backend/sexpression.cc
deleted file mode 100644
index 7307ef3..0000000
--- a/runtime/vm/compiler/backend/sexpression.cc
+++ /dev/null
@@ -1,686 +0,0 @@
-// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-#include "vm/compiler/backend/sexpression.h"
-
-#include <ctype.h>
-#include "platform/utils.h"
-#include "vm/double_conversion.h"
-#include "vm/zone_text_buffer.h"
-
-namespace dart {
-
-SExpression* SExpression::FromCString(Zone* zone, const char* str) {
-  SExpParser parser(zone, str);
-  auto sexp = parser.Parse();
-  if (sexp == nullptr) parser.ReportError();
-  return sexp;
-}
-
-const char* SExpression::ToCString(Zone* zone) const {
-  ZoneTextBuffer buf(zone, 1 * KB);
-  SerializeToLine(&buf);
-  return buf.buffer();
-}
-
-bool SExpBool::Equals(SExpression* sexp) const {
-  if (auto const b = sexp->AsBool()) return b->Equals(value());
-  return false;
-}
-
-bool SExpBool::Equals(bool val) const {
-  return value() == val;
-}
-
-void SExpBool::SerializeToLine(BaseTextBuffer* buffer) const {
-  buffer->AddString(value() ? SExpParser::kBoolTrueSymbol
-                            : SExpParser::kBoolFalseSymbol);
-}
-
-bool SExpDouble::Equals(SExpression* sexp) const {
-  if (auto const d = sexp->AsDouble()) return d->Equals(value());
-  return false;
-}
-
-bool SExpDouble::Equals(double val) const {
-  return value() == val;
-}
-
-void SExpDouble::SerializeToLine(BaseTextBuffer* buffer) const {
-  // Use existing Dart serialization for Doubles.
-  const intptr_t kBufSize = 128;
-  char strbuf[kBufSize];
-  DoubleToCString(value(), strbuf, kBufSize);
-  buffer->Printf("%s", strbuf);
-}
-
-bool SExpInteger::Equals(SExpression* sexp) const {
-  if (auto const i = sexp->AsInteger()) return i->Equals(value());
-  return false;
-}
-
-bool SExpInteger::Equals(int64_t val) const {
-  return value() == val;
-}
-
-void SExpInteger::SerializeToLine(BaseTextBuffer* buffer) const {
-  buffer->Printf("%" Pd64 "", value());
-}
-
-bool SExpString::Equals(SExpression* sexp) const {
-  if (auto const s = sexp->AsString()) return s->Equals(value());
-  return false;
-}
-
-bool SExpString::Equals(const char* str) const {
-  return strcmp(value(), str) == 0;
-}
-
-void SExpString::SerializeToLine(BaseTextBuffer* buffer) const {
-  TextBuffer buf(80);
-  buf.AddChar('"');
-  buf.AddEscapedString(value());
-  buf.AddChar('"');
-  buffer->AddString(buf.buffer());
-}
-
-bool SExpSymbol::Equals(SExpression* sexp) const {
-  if (auto const s = sexp->AsSymbol()) return s->Equals(value());
-  return false;
-}
-
-bool SExpSymbol::Equals(const char* str) const {
-  return strcmp(value(), str) == 0;
-}
-
-void SExpSymbol::SerializeToLine(BaseTextBuffer* buffer) const {
-  buffer->AddString(value());
-}
-
-void SExpList::Add(SExpression* sexp) {
-  contents_.Add(sexp);
-}
-
-void SExpList::AddExtra(const char* label, SExpression* value) {
-  ASSERT(!extra_info_.HasKey(label));
-  extra_info_.Insert({label, value});
-}
-
-bool SExpList::Equals(SExpression* sexp) const {
-  if (!sexp->IsList()) return false;
-  auto list = sexp->AsList();
-  if (Length() != list->Length()) return false;
-  if (ExtraLength() != list->ExtraLength()) return false;
-  for (intptr_t i = 0; i < Length(); i++) {
-    if (!At(i)->Equals(list->At(i))) return false;
-  }
-  auto this_it = ExtraIterator();
-  while (auto kv = this_it.Next()) {
-    if (!list->ExtraHasKey(kv->key)) return false;
-    if (!kv->value->Equals(list->ExtraLookupValue(kv->key))) return false;
-  }
-  return true;
-}
-
-const char* const SExpList::kElemIndent = " ";
-const char* const SExpList::kExtraIndent = "  ";
-
-static intptr_t HandleLineBreaking(Zone* zone,
-                                   BaseTextBuffer* buffer,
-                                   SExpression* element,
-                                   BaseTextBuffer* line_buffer,
-                                   const char* sub_indent,
-                                   intptr_t width,
-                                   bool leading_space,
-                                   intptr_t remaining) {
-  element->SerializeToLine(line_buffer);
-  const intptr_t single_line_width = line_buffer->length();
-  const intptr_t leading_length = leading_space ? 1 : 0;
-
-  if ((leading_length + single_line_width) < remaining) {
-    if (leading_space) buffer->AddChar(' ');
-    buffer->AddString(line_buffer->buffer());
-    line_buffer->Clear();
-    return remaining - (leading_length + single_line_width);
-  }
-  const intptr_t old_length = buffer->length();
-  buffer->Printf("\n%s", sub_indent);
-  const intptr_t line_used = buffer->length() - old_length + 1;
-  remaining = width - line_used;
-  if ((single_line_width < remaining) || element->IsAtom()) {
-    buffer->AddString(line_buffer->buffer());
-    line_buffer->Clear();
-    return remaining - single_line_width;
-  }
-  line_buffer->Clear();
-  element->SerializeTo(zone, buffer, sub_indent, width);
-  return 0;
-}
-
-// Assumes that we are starting on a line after [indent] amount of space.
-void SExpList::SerializeTo(Zone* zone,
-                           BaseTextBuffer* buffer,
-                           const char* indent,
-                           intptr_t width) const {
-  TextBuffer single_line(width);
-  const char* sub_indent = OS::SCreate(zone, "%s%s", indent, kElemIndent);
-
-  buffer->AddChar('(');
-  intptr_t remaining = width - strlen(indent) - 1;
-  for (intptr_t i = 0; i < contents_.length(); i++) {
-    remaining = HandleLineBreaking(zone, buffer, contents_.At(i), &single_line,
-                                   sub_indent, width, i != 0, remaining);
-  }
-
-  if (!extra_info_.IsEmpty()) {
-    SerializeExtraInfoToLine(&single_line);
-    if (single_line.length() < remaining - 1) {
-      buffer->Printf(" %s", single_line.buffer());
-    } else {
-      const intptr_t old_length = buffer->length();
-      buffer->Printf("\n%s", sub_indent);
-      const intptr_t line_used = buffer->length() - old_length + 1;
-      remaining = width - line_used;
-      if (single_line.length() < remaining) {
-        buffer->AddString(single_line.buffer());
-      } else {
-        SerializeExtraInfoTo(zone, buffer, sub_indent, width);
-      }
-    }
-  }
-  buffer->AddChar(')');
-}
-
-void SExpList::SerializeToLine(BaseTextBuffer* buffer) const {
-  buffer->AddChar('(');
-  for (intptr_t i = 0; i < contents_.length(); i++) {
-    if (i != 0) buffer->AddChar(' ');
-    contents_.At(i)->SerializeToLine(buffer);
-  }
-  if (!extra_info_.IsEmpty()) {
-    buffer->AddChar(' ');
-    SerializeExtraInfoToLine(buffer);
-  }
-  buffer->AddChar(')');
-}
-
-void SExpList::SerializeExtraInfoTo(Zone* zone,
-                                    BaseTextBuffer* buffer,
-                                    const char* indent,
-                                    int width) const {
-  const char* sub_indent = OS::SCreate(zone, "%s%s", indent, kExtraIndent);
-  TextBuffer single_line(width);
-
-  buffer->AddChar('{');
-  auto it = ExtraIterator();
-  while (auto kv = it.Next()) {
-    const intptr_t old_length = buffer->length();
-    buffer->Printf("\n%s%s", sub_indent, kv->key);
-    const intptr_t remaining = width - (buffer->length() - old_length + 1);
-    HandleLineBreaking(zone, buffer, kv->value, &single_line, sub_indent, width,
-                       /*leading_space=*/true, remaining);
-    buffer->AddChar(',');
-  }
-  buffer->Printf("\n%s}", indent);
-}
-
-void SExpList::SerializeExtraInfoToLine(BaseTextBuffer* buffer) const {
-  buffer->AddString("{");
-  auto it = ExtraIterator();
-  while (auto kv = it.Next()) {
-    buffer->Printf(" %s ", kv->key);
-    kv->value->SerializeToLine(buffer);
-    buffer->AddChar(',');
-  }
-  buffer->AddString(" }");
-}
-
-const char* const SExpParser::kBoolTrueSymbol = "true";
-const char* const SExpParser::kBoolFalseSymbol = "false";
-char const SExpParser::kDoubleExponentChar =
-    DoubleToStringConstants::kExponentChar;
-const char* const SExpParser::kDoubleInfinitySymbol =
-    DoubleToStringConstants::kInfinitySymbol;
-const char* const SExpParser::kDoubleNaNSymbol =
-    DoubleToStringConstants::kNaNSymbol;
-
-const char* const SExpParser::ErrorStrings::kOpenString =
-    "unterminated quoted string starting at position %" Pd "";
-const char* const SExpParser::ErrorStrings::kBadUnicodeEscape =
-    "malformed Unicode escape";
-const char* const SExpParser::ErrorStrings::kOpenSExpList =
-    "unterminated S-expression list starting at position %" Pd "";
-const char* const SExpParser::ErrorStrings::kOpenMap =
-    "unterminated extra info map starting at position %" Pd "";
-const char* const SExpParser::ErrorStrings::kNestedMap =
-    "extra info map start when already within extra info map";
-const char* const SExpParser::ErrorStrings::kMapOutsideList =
-    "extra info map start not within S-expression list";
-const char* const SExpParser::ErrorStrings::kNonSymbolLabel =
-    "non-symbol in label position for extra info map";
-const char* const SExpParser::ErrorStrings::kNoMapLabel =
-    "no extra info map label provided";
-const char* const SExpParser::ErrorStrings::kRepeatedMapLabel =
-    "extra info map label %s provided more than once";
-const char* const SExpParser::ErrorStrings::kNoMapValue =
-    "no value provided for extra info map label %s";
-const char* const SExpParser::ErrorStrings::kExtraMapValue =
-    "extra value following label %s in extra info map";
-const char* const SExpParser::ErrorStrings::kUnexpectedComma =
-    "comma found outside extra info map";
-const char* const SExpParser::ErrorStrings::kUnexpectedRightParen =
-    "unexpected closing parenthesis";
-const char* const SExpParser::ErrorStrings::kUnexpectedRightCurly =
-    "unexpected closing curly brace";
-
-#define PARSE_ERROR(x, ...)                                                    \
-  StoreError(x, __VA_ARGS__);                                                  \
-  return nullptr
-
-SExpression* SExpParser::Parse() {
-  Reset();
-  while (auto token = GetNextToken()) {
-    const intptr_t start_pos = token->cstr() - buffer_;
-    switch (token->type()) {
-      case kLeftParen: {
-        if (in_extra_) {
-          if (cur_label_ == nullptr) {
-            PARSE_ERROR(start_pos, ErrorStrings::kNonSymbolLabel);
-          } else if (cur_value_ != nullptr) {
-            PARSE_ERROR(start_pos, ErrorStrings::kExtraMapValue, cur_label_);
-          }
-        }
-        auto sexp = new (zone_) SExpList(zone_, start_pos);
-        list_stack_.Add(sexp);
-        in_extra_stack_.Add(in_extra_);
-        extra_start_stack_.Add(extra_start_);
-        cur_label_stack_.Add(cur_label_);
-        in_extra_ = false;
-        extra_start_ = -1;
-        cur_label_ = nullptr;
-        break;
-      }
-      case kRightParen: {
-        if (list_stack_.is_empty()) {
-          PARSE_ERROR(start_pos, ErrorStrings::kUnexpectedRightParen);
-        }
-        if (in_extra_) {
-          PARSE_ERROR(start_pos, ErrorStrings::kOpenMap, extra_start_);
-        }
-        auto sexp = list_stack_.RemoveLast();
-        in_extra_ = in_extra_stack_.RemoveLast();
-        extra_start_ = extra_start_stack_.RemoveLast();
-        cur_label_ = cur_label_stack_.RemoveLast();
-        if (list_stack_.is_empty()) return sexp;
-        if (in_extra_) {
-          if (cur_label_ == nullptr) {
-            PARSE_ERROR(start_pos, ErrorStrings::kOpenMap, extra_start_);
-          }
-          cur_value_ = sexp;
-        } else {
-          list_stack_.Last()->Add(sexp);
-        }
-        break;
-      }
-      case kLeftCurly:
-        if (in_extra_) {
-          PARSE_ERROR(start_pos, ErrorStrings::kNestedMap);
-        }
-        if (list_stack_.is_empty()) {
-          PARSE_ERROR(start_pos, ErrorStrings::kMapOutsideList);
-        }
-        extra_start_ = start_pos;
-        in_extra_ = true;
-        break;
-      case kRightCurly:
-        if (!in_extra_ || list_stack_.is_empty()) {
-          PARSE_ERROR(start_pos, ErrorStrings::kUnexpectedRightCurly);
-        }
-        if (cur_label_ != nullptr) {
-          if (cur_value_ == nullptr) {
-            PARSE_ERROR(start_pos, ErrorStrings::kNoMapValue, cur_label_);
-          }
-          list_stack_.Last()->AddExtra(cur_label_, cur_value_);
-          cur_label_ = nullptr;
-          cur_value_ = nullptr;
-        }
-        in_extra_ = false;
-        extra_start_ = -1;
-        break;
-      case kComma: {
-        if (!in_extra_ || list_stack_.is_empty()) {
-          PARSE_ERROR(start_pos, ErrorStrings::kUnexpectedComma);
-        }
-        if (cur_label_ == nullptr) {
-          PARSE_ERROR(start_pos, ErrorStrings::kNoMapLabel);
-        } else if (cur_value_ == nullptr) {
-          PARSE_ERROR(start_pos, ErrorStrings::kNoMapValue, cur_label_);
-        }
-        list_stack_.Last()->AddExtra(cur_label_, cur_value_);
-        cur_label_ = nullptr;
-        cur_value_ = nullptr;
-        break;
-      }
-      case kSymbol: {
-        auto sexp = TokenToSExpression(token);
-        ASSERT(sexp->IsSymbol());
-        if (in_extra_) {
-          if (cur_value_ != nullptr) {
-            PARSE_ERROR(start_pos, ErrorStrings::kExtraMapValue, cur_label_);
-          }
-          if (cur_label_ == nullptr) {
-            const char* const label = sexp->AsSymbol()->value();
-            if (list_stack_.Last()->ExtraHasKey(label)) {
-              PARSE_ERROR(start_pos, ErrorStrings::kRepeatedMapLabel, label);
-            }
-            cur_label_ = sexp->AsSymbol()->value();
-          } else {
-            cur_value_ = sexp;
-          }
-        } else if (!list_stack_.is_empty()) {
-          list_stack_.Last()->Add(sexp);
-        } else {
-          return sexp;
-        }
-        break;
-      }
-      case kBoolean:
-      case kInteger:
-      case kDouble:
-      case kQuotedString: {
-        auto sexp = TokenToSExpression(token);
-        // TokenToSExpression has already set the error info, so just return.
-        if (sexp == nullptr) return nullptr;
-        if (in_extra_) {
-          if (cur_label_ == nullptr) {
-            PARSE_ERROR(start_pos, ErrorStrings::kNonSymbolLabel);
-          } else if (cur_value_ != nullptr) {
-            PARSE_ERROR(start_pos, ErrorStrings::kExtraMapValue, cur_label_);
-          }
-          cur_value_ = sexp;
-        } else if (!list_stack_.is_empty()) {
-          list_stack_.Last()->Add(sexp);
-        } else {
-          return sexp;
-        }
-        break;
-      }
-      default:
-        UNREACHABLE();
-    }
-  }
-  if (in_extra_) {
-    PARSE_ERROR(buffer_size_, ErrorStrings::kOpenMap, extra_start_);
-  } else if (!list_stack_.is_empty()) {
-    const intptr_t list_start = list_stack_.Last()->start();
-    PARSE_ERROR(buffer_size_, ErrorStrings::kOpenSExpList, list_start);
-  }
-  UNREACHABLE();
-}
-
-SExpression* SExpParser::TokenToSExpression(Token* token) {
-  const intptr_t start_pos = token->cstr() - buffer_;
-  switch (token->type()) {
-    case kSymbol:
-      return new (zone_) SExpSymbol(token->ToCString(zone_), start_pos);
-    case kInteger: {
-      const char* cstr = token->ToCString(zone_);
-      int64_t val;
-      if (!OS::StringToInt64(cstr, &val)) return nullptr;
-      return new (zone_) SExpInteger(val, start_pos);
-    }
-    case kBoolean: {
-      const bool is_true =
-          strncmp(token->cstr(), kBoolTrueSymbol, token->length()) == 0;
-      ASSERT(is_true ||
-             strncmp(token->cstr(), kBoolFalseSymbol, token->length()) == 0);
-      return new (zone_) SExpBool(is_true, start_pos);
-    }
-    case kDouble: {
-      double val;
-      if (!CStringToDouble(token->cstr(), token->length(), &val)) {
-        return nullptr;
-      }
-      return new (zone_) SExpDouble(val, start_pos);
-    }
-    case kQuotedString: {
-      const char* const cstr = token->cstr();
-      char* const buf = zone_->Alloc<char>(token->length());
-      // Skip the initial quote
-      ASSERT(cstr[0] == '"');
-      intptr_t old_pos = 1;
-      intptr_t new_pos = 0;
-      // The string _should_ end in a quote.
-      while (old_pos < token->length() - 1) {
-        if (cstr[old_pos] == '"') break;
-        if (cstr[old_pos] != '\\') {
-          buf[new_pos++] = cstr[old_pos++];
-          continue;
-        }
-        old_pos++;
-        if (old_pos >= token->length()) {
-          PARSE_ERROR(start_pos + old_pos, ErrorStrings::kOpenString,
-                      start_pos);
-        }
-        const intptr_t escape_pos = start_pos + old_pos - 1;
-        switch (cstr[old_pos]) {
-          case 'b':
-            buf[new_pos] = '\b';
-            break;
-          case 'f':
-            buf[new_pos] = '\f';
-            break;
-          case 'n':
-            buf[new_pos] = '\n';
-            break;
-          case 'r':
-            buf[new_pos] = '\r';
-            break;
-          case 't':
-            buf[new_pos] = '\t';
-            break;
-          case 'u': {
-            const intptr_t first = old_pos + 1;
-            const intptr_t last = old_pos + 4;
-            if (last >= token->length()) {
-              PARSE_ERROR(escape_pos, ErrorStrings::kBadUnicodeEscape);
-            }
-            intptr_t val = 0;
-            for (const char *cursor = cstr + first, *end = cstr + last + 1;
-                 cursor < end; cursor++) {
-              val *= 16;
-              if (!Utils::IsHexDigit(*cursor)) {
-                PARSE_ERROR(escape_pos, ErrorStrings::kBadUnicodeEscape);
-              }
-              val += Utils::HexDigitToInt(*cursor);
-            }
-            // Currently, just handle encoded ASCII instead of doing
-            // handling Unicode characters.
-            // (TextBuffer::AddEscapedString uses this for characters < 0x20.)
-            ASSERT(val <= 0x7F);
-            old_pos = last;
-            buf[new_pos] = val;
-            break;
-          }
-          default:
-            // Identity escapes.
-            buf[new_pos] = cstr[old_pos];
-            break;
-        }
-        old_pos++;
-        new_pos++;
-      }
-      if (cstr[old_pos] != '"') {
-        PARSE_ERROR(start_pos + token->length(), ErrorStrings::kOpenString,
-                    start_pos);
-      }
-      buf[new_pos] = '\0';
-      return new (zone_) SExpString(buf, start_pos);
-    }
-    default:
-      UNREACHABLE();
-  }
-}
-
-#undef PARSE_ERROR
-
-SExpParser::Token* SExpParser::GetNextToken() {
-  intptr_t start_pos = cur_pos_;
-  while (start_pos < buffer_size_) {
-    if (isspace(buffer_[start_pos]) == 0) break;
-    start_pos++;
-  }
-  if (start_pos >= buffer_size_) return nullptr;
-  const char* start = buffer_ + start_pos;
-  switch (*start) {
-    case '(':
-      cur_pos_ = start_pos + 1;
-      return new (zone_) Token(kLeftParen, start, 1);
-    case ')':
-      cur_pos_ = start_pos + 1;
-      return new (zone_) Token(kRightParen, start, 1);
-    case ',':
-      cur_pos_ = start_pos + 1;
-      return new (zone_) Token(kComma, start, 1);
-    case '{':
-      cur_pos_ = start_pos + 1;
-      return new (zone_) Token(kLeftCurly, start, 1);
-    case '}':
-      cur_pos_ = start_pos + 1;
-      return new (zone_) Token(kRightCurly, start, 1);
-    case '"': {
-      intptr_t len = 1;
-      while (start_pos + len < buffer_size_) {
-        char curr = start[len];
-        len++;  // Length should include the quote, if any.
-        if (curr == '\\') {
-          // Skip past next character (if any), since it cannot
-          // end the quoted string due to being escaped.
-          if (start_pos + len >= buffer_size_) break;
-          len++;
-          continue;
-        }
-        if (curr == '"') break;
-      }
-      cur_pos_ = start_pos + len;
-      return new (zone_) Token(kQuotedString, start, len);
-    }
-    default:
-      break;
-  }
-  intptr_t len = 0;
-  // Start number detection after possible negation sign.
-  if (start[len] == '-') {
-    len++;
-    if ((start_pos + len) >= buffer_size_) {
-      cur_pos_ = start_pos + len;
-      return new (zone_) Token(kSymbol, start, len);
-    }
-  }
-  // Keep the currently detected token type. Start off by assuming we have
-  // an integer, then fall back to doubles if we see parts appropriate for
-  // those but not integers, and fall back to symbols otherwise.
-  TokenType type = kInteger;
-  bool saw_exponent = false;
-  while ((start_pos + len) < buffer_size_) {
-    // Both numbers and symbols cannot contain these values, so we are at the
-    // end of whichever one we're in.
-    if (!IsSymbolContinue(start[len])) break;
-    if (type == kInteger && start[len] == '.') {
-      type = kDouble;
-      len++;
-      continue;
-    }
-    if (type != kSymbol && !saw_exponent && start[len] == kDoubleExponentChar) {
-      saw_exponent = true;
-      type = kDouble;
-      len++;
-      // Skip past negation in exponent if any.
-      if ((start_pos + len) < buffer_size_ && start[len] == '-') len++;
-      continue;
-    }
-    // If we find a character that can't appear in a number, then fall back
-    // to symbol-ness.
-    if (isdigit(start[len]) == 0) type = kSymbol;
-    len++;
-  }
-  cur_pos_ = start_pos + len;
-  // Skip special symbol detection if we don't have a symbol.
-  if (type != kSymbol) return new (zone_) Token(type, start, len);
-  // Check for special symbols used for booleans and certain Double values.
-  switch (len) {
-    case 3:
-      if (strncmp(start, kDoubleNaNSymbol, len) == 0) type = kDouble;
-      break;
-    case 4:
-      if (strncmp(start, kBoolTrueSymbol, len) == 0) type = kBoolean;
-      break;
-    case 5:
-      if (strncmp(start, kBoolFalseSymbol, len) == 0) type = kBoolean;
-      break;
-    case 8:
-      if (strncmp(start, kDoubleInfinitySymbol, len) == 0) type = kDouble;
-      break;
-    case 9:
-      if (start[0] == '-' &&
-          strncmp(start + 1, kDoubleInfinitySymbol, len - 1) == 0) {
-        type = kDouble;
-      }
-      break;
-    default:
-      break;
-  }
-  return new (zone_) Token(type, start, len);
-}
-
-bool SExpParser::IsSymbolContinue(char c) {
-  return (isspace(c) == 0) && c != '(' && c != ')' && c != ',' && c != '{' &&
-         c != '}' && c != '"';
-}
-
-const char* const SExpParser::Token::TokenNames[kMaxTokens] = {
-#define S_EXP_TOKEN_NAME_STRING(name) #name,
-    S_EXP_TOKEN_LIST(S_EXP_TOKEN_NAME_STRING)
-#undef S_EXP_TOKEN_NAME_STRING
-};
-
-const char* SExpParser::Token::ToCString(Zone* zone) {
-  char* const buffer = zone->Alloc<char>(len_ + 1);
-  strncpy(buffer, cstr_, len_);
-  buffer[len_] = '\0';
-  return buffer;
-}
-
-void SExpParser::Reset() {
-  cur_pos_ = 0;
-  in_extra_ = false;
-  extra_start_ = -1;
-  cur_label_ = nullptr;
-  cur_value_ = nullptr;
-  list_stack_.Clear();
-  in_extra_stack_.Clear();
-  extra_start_stack_.Clear();
-  cur_label_stack_.Clear();
-  error_pos_ = -1;
-  error_message_ = nullptr;
-}
-
-void SExpParser::StoreError(intptr_t pos, const char* format, ...) {
-  va_list args;
-  va_start(args, format);
-  const char* const message = OS::VSCreate(zone_, format, args);
-  va_end(args);
-  error_pos_ = pos;
-  error_message_ = message;
-}
-
-void SExpParser::ReportError() const {
-  ASSERT(error_message_ != nullptr);
-  ASSERT(error_pos_ >= 0);
-  OS::PrintErr("Unable to parse s-expression: %s\n", buffer_);
-  OS::PrintErr("Error at character %" Pd ": %s\n", error_pos_, error_message_);
-  OS::Abort();
-}
-
-}  // namespace dart
diff --git a/runtime/vm/compiler/backend/sexpression.h b/runtime/vm/compiler/backend/sexpression.h
deleted file mode 100644
index 6bdc36e..0000000
--- a/runtime/vm/compiler/backend/sexpression.h
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright (c) 2019, 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.
-
-#ifndef RUNTIME_VM_COMPILER_BACKEND_SEXPRESSION_H_
-#define RUNTIME_VM_COMPILER_BACKEND_SEXPRESSION_H_
-
-#if defined(DART_PRECOMPILED_RUNTIME)
-#error "AOT runtime should not use compiler sources (including header files)"
-#endif  // defined(DART_PRECOMPILED_RUNTIME)
-
-#include "platform/text_buffer.h"
-
-#include "vm/allocation.h"
-#include "vm/growable_array.h"
-#include "vm/hash_map.h"
-#include "vm/zone.h"
-
-namespace dart {
-
-#define FOR_EACH_S_EXPRESSION_ATOM(M)                                          \
-  M(Bool, bool)                                                                \
-  M(Double, double)                                                            \
-  M(Integer, int64_t)                                                          \
-  M(String, const char*)                                                       \
-  M(Symbol, const char*)
-
-#define FOR_EACH_S_EXPRESSION(M)                                               \
-  FOR_EACH_S_EXPRESSION_ATOM(M)                                                \
-  M(List, _)
-
-#define FOR_EACH_ABSTRACT_S_EXPRESSION(M) M(Atom, _)
-
-#define FORWARD_DECLARATION(name, value_type) class SExp##name;
-FOR_EACH_S_EXPRESSION(FORWARD_DECLARATION)
-FOR_EACH_ABSTRACT_S_EXPRESSION(FORWARD_DECLARATION)
-#undef FORWARD_DECLARATION
-
-// Abstract base class for S-expressions used as an intermediate form for the
-// IL serializer. These aren't true (LISP-like) S-expressions, as the atoms
-// are more restricted and the lists have extra information. Here is an
-// illustrative BNF-style grammar of the current serialized form of
-// S-expressions that includes non-whitespace literal tokens:
-//
-// <s-exp>      ::= <atom> | <list>
-// <atom>       ::= <bool> | <integer> | <string> | <symbol>
-// <list>       ::= '(' <s-exp>* <extra-info>? ')'
-// <extra-info> ::= '{' <extra-elem>* '}'
-// <extra-elem> ::= <symbol> <s-exp> ','
-//
-// Here, <string>s are double-quoted strings with backslash escaping and
-// <symbol>s are sequences of consecutive non-whitespace characters that do not
-// include commas (,), parentheses (()), curly braces ({}), or the double-quote
-// character (").
-//
-// In addition, the <extra-info> is considered a map from symbol labels to
-// S-expression values, and as such each symbol used as a key in an <extra-info>
-// block should only appear once as a key within that block.
-class SExpression : public ZoneAllocated {
- public:
-  explicit SExpression(intptr_t start = kInvalidPos) : start_(start) {}
-  virtual ~SExpression() {}
-
-  static intptr_t const kInvalidPos = -1;
-
-  static SExpression* FromCString(Zone* zone, const char* cstr);
-  const char* ToCString(Zone* zone) const;
-  intptr_t start() const { return start_; }
-
-#define S_EXPRESSION_TYPE_CHECK(name, value_type)                              \
-  bool Is##name() const { return (As##name() != nullptr); }                    \
-  SExp##name* As##name() {                                                     \
-    auto const const_this = const_cast<const SExpression*>(this);              \
-    return const_cast<SExp##name*>(const_this->As##name());                    \
-  }                                                                            \
-  virtual const SExp##name* As##name() const { return nullptr; }
-
-  FOR_EACH_S_EXPRESSION(S_EXPRESSION_TYPE_CHECK)
-  FOR_EACH_ABSTRACT_S_EXPRESSION(S_EXPRESSION_TYPE_CHECK)
-
-  virtual const char* DebugName() const = 0;
-  virtual bool Equals(SExpression* sexp) const = 0;
-  virtual void SerializeTo(Zone* zone,
-                           BaseTextBuffer* buffer,
-                           const char* indent,
-                           intptr_t width = 80) const = 0;
-  virtual void SerializeToLine(BaseTextBuffer* buffer) const = 0;
-
- private:
-  // Starting character position of the s-expression in the original
-  // serialization, if it was deserialized.
-  intptr_t const start_;
-  DISALLOW_COPY_AND_ASSIGN(SExpression);
-};
-
-class SExpAtom : public SExpression {
- public:
-  explicit SExpAtom(intptr_t start = kInvalidPos) : SExpression(start) {}
-
-  virtual const SExpAtom* AsAtom() const { return this; }
-  // No atoms have sub-elements, so they always print to a single line.
-  virtual void SerializeTo(Zone* zone,
-                           BaseTextBuffer* buffer,
-                           const char* indent,
-                           intptr_t width = 80) const {
-    SerializeToLine(buffer);
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(SExpAtom);
-};
-
-#define DEFINE_S_EXPRESSION_TYPE_CHECK(name)                                   \
-  virtual const SExp##name* As##name() const { return this; }                  \
-  virtual const char* DebugName() const { return #name; }
-
-// The various concrete S-expression atom classes are thin wrappers around
-// their contained value that includes serialization and type check methods.
-#define DEFINE_S_EXPRESSION_ATOM_CLASS(name, value_type)                       \
-  class SExp##name : public SExpAtom {                                         \
-   public:                                                                     \
-    explicit SExp##name(value_type val, intptr_t start = kInvalidPos)          \
-        : SExpAtom(start), val_(val) {}                                        \
-    value_type value() const { return val_; }                                  \
-    virtual bool Equals(SExpression* sexp) const;                              \
-    bool Equals(value_type val) const;                                         \
-    virtual void SerializeToLine(BaseTextBuffer* buffer) const;                \
-    DEFINE_S_EXPRESSION_TYPE_CHECK(name)                                       \
-   private:                                                                    \
-    value_type const val_;                                                     \
-    DISALLOW_COPY_AND_ASSIGN(SExp##name);                                      \
-  };
-
-FOR_EACH_S_EXPRESSION_ATOM(DEFINE_S_EXPRESSION_ATOM_CLASS)
-
-// A list of S-expressions. Unlike normal S-expressions, an S-expression list
-// also contains a hash map kept separate from the elements, which we use for
-// extra non-argument information for IL instructions.
-class SExpList : public SExpression {
- public:
-  explicit SExpList(Zone* zone, intptr_t start = kInvalidPos)
-      : SExpression(start), contents_(zone, 2), extra_info_(zone) {}
-
-  using ExtraInfoHashMap = CStringMap<SExpression*>;
-
-  void Add(SExpression* sexp);
-  void AddExtra(const char* label, SExpression* value);
-
-  SExpression* At(intptr_t i) const { return contents_.At(i); }
-  intptr_t Length() const { return contents_.length(); }
-
-  intptr_t ExtraLength() const { return extra_info_.Length(); }
-  ExtraInfoHashMap::Iterator ExtraIterator() const {
-    return extra_info_.GetIterator();
-  }
-  bool ExtraHasKey(const char* cstr) const { return extra_info_.HasKey(cstr); }
-  SExpression* ExtraLookupValue(const char* cstr) const {
-    return extra_info_.LookupValue(cstr);
-  }
-
-  // Shortcut for retrieving the tag from a tagged list (list that contains an
-  // initial symbol). Returns nullptr if the list is not a tagged list.
-  SExpSymbol* Tag() const {
-    if (Length() == 0 || !At(0)->IsSymbol()) return nullptr;
-    return At(0)->AsSymbol();
-  }
-
-  DEFINE_S_EXPRESSION_TYPE_CHECK(List)
-  virtual bool Equals(SExpression* sexp) const;
-  virtual void SerializeTo(Zone* zone,
-                           BaseTextBuffer* buffer,
-                           const char* indent,
-                           intptr_t width = 80) const;
-  virtual void SerializeToLine(BaseTextBuffer* buffer) const;
-
- private:
-  static const char* const kElemIndent;
-  static const char* const kExtraIndent;
-
-  void SerializeExtraInfoTo(Zone* zone,
-                            BaseTextBuffer* buffer,
-                            const char* indent,
-                            int width) const;
-  void SerializeExtraInfoToLine(BaseTextBuffer* buffer) const;
-
-  ZoneGrowableArray<SExpression*> contents_;
-  ExtraInfoHashMap extra_info_;
-
-  DISALLOW_COPY_AND_ASSIGN(SExpList);
-};
-
-class SExpParser : public ValueObject {
- public:
-  SExpParser(Zone* zone, const char* cstr)
-      : SExpParser(zone, cstr, strlen(cstr)) {}
-  SExpParser(Zone* zone, const char* cstr, intptr_t len)
-      : zone_(zone),
-        buffer_(ASSERT_NOTNULL(cstr)),
-        buffer_size_(strnlen(cstr, len)),
-        cur_label_(nullptr),
-        cur_value_(nullptr),
-        list_stack_(zone, 2),
-        in_extra_stack_(zone, 2),
-        extra_start_stack_(zone, 2),
-        cur_label_stack_(zone, 2),
-        error_message_(nullptr) {}
-
-  // Constants used in serializing and deserializing S-expressions.
-  static const char* const kBoolTrueSymbol;
-  static const char* const kBoolFalseSymbol;
-  static char const kDoubleExponentChar;
-  static const char* const kDoubleInfinitySymbol;
-  static const char* const kDoubleNaNSymbol;
-
-  struct ErrorStrings : AllStatic {
-    static const char* const kOpenString;
-    static const char* const kBadUnicodeEscape;
-    static const char* const kOpenSExpList;
-    static const char* const kOpenMap;
-    static const char* const kNestedMap;
-    static const char* const kMapOutsideList;
-    static const char* const kNonSymbolLabel;
-    static const char* const kNoMapLabel;
-    static const char* const kRepeatedMapLabel;
-    static const char* const kNoMapValue;
-    static const char* const kExtraMapValue;
-    static const char* const kUnexpectedComma;
-    static const char* const kUnexpectedRightParen;
-    static const char* const kUnexpectedRightCurly;
-  };
-
-  intptr_t error_pos() const { return error_pos_; }
-  const char* error_message() const { return error_message_; }
-
-  const char* Input() const { return buffer_; }
-  SExpression* Parse();
-  DART_NORETURN void ReportError() const;
-
- private:
-#define S_EXP_TOKEN_LIST(M)                                                    \
-  M(LeftParen)                                                                 \
-  M(RightParen)                                                                \
-  M(Comma)                                                                     \
-  M(LeftCurly)                                                                 \
-  M(RightCurly)                                                                \
-  M(QuotedString)                                                              \
-  M(Integer)                                                                   \
-  M(Double)                                                                    \
-  M(Boolean)                                                                   \
-  M(Symbol)
-
-  // clang-format off
-#define DEFINE_S_EXP_TOKEN_ENUM_LINE(name) k##name,
-  enum TokenType {
-    S_EXP_TOKEN_LIST(DEFINE_S_EXP_TOKEN_ENUM_LINE)
-    kMaxTokens,
-  };
-#undef DEFINE_S_EXP_TOKEN_ENUM
-  // clang-format on
-
-  class Token : public ZoneAllocated {
-   public:
-    Token(TokenType type, const char* cstr, intptr_t len)
-        : type_(type), cstr_(cstr), len_(len) {}
-
-    TokenType type() const { return type_; }
-    intptr_t length() const { return len_; }
-    const char* cstr() const { return cstr_; }
-    const char* DebugName() const { return TokenNames[type()]; }
-    const char* ToCString(Zone* zone);
-
-   private:
-    static const char* const TokenNames[kMaxTokens];
-
-    TokenType const type_;
-    const char* const cstr_;
-    intptr_t const len_;
-  };
-
-  SExpression* TokenToSExpression(Token* token);
-  Token* GetNextToken();
-  void Reset();
-  void StoreError(intptr_t pos, const char* format, ...) PRINTF_ATTRIBUTE(3, 4);
-
-  static bool IsSymbolContinue(char c);
-
-  Zone* const zone_;
-  const char* const buffer_;
-  intptr_t const buffer_size_;
-  intptr_t cur_pos_ = 0;
-  bool in_extra_ = false;
-  intptr_t extra_start_ = -1;
-  const char* cur_label_;
-  SExpression* cur_value_;
-  ZoneGrowableArray<SExpList*> list_stack_;
-  ZoneGrowableArray<bool> in_extra_stack_;
-  ZoneGrowableArray<intptr_t> extra_start_stack_;
-  ZoneGrowableArray<const char*> cur_label_stack_;
-  intptr_t error_pos_ = -1;
-  const char* error_message_;
-};
-
-}  // namespace dart
-
-#endif  // RUNTIME_VM_COMPILER_BACKEND_SEXPRESSION_H_
diff --git a/runtime/vm/compiler/backend/sexpression_test.cc b/runtime/vm/compiler/backend/sexpression_test.cc
deleted file mode 100644
index 8c0edac..0000000
--- a/runtime/vm/compiler/backend/sexpression_test.cc
+++ /dev/null
@@ -1,355 +0,0 @@
-// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-#include "vm/compiler/backend/sexpression.h"
-
-#include <cmath>
-#include "platform/assert.h"
-#include "vm/unit_test.h"
-
-namespace dart {
-
-#define EXPECT_SEXP_PARSE_ERROR(sexp, parser, pos, message)                    \
-  do {                                                                         \
-    if (sexp != nullptr) {                                                     \
-      dart::Expect(__FILE__, __LINE__)                                         \
-          .Fail("parse unexpectedly succeeded for \"%s\"", parser.Input());    \
-    }                                                                          \
-    EXPECT_EQ(pos, parser.error_pos());                                        \
-    EXPECT_STREQ(message, parser.error_message());                             \
-  } while (false);
-
-#define EXPECT_SEXP_PARSE_SUCCESS(sexp, parser)                                \
-  do {                                                                         \
-    if (sexp == nullptr) {                                                     \
-      EXPECT_NOTNULL(parser.error_message());                                  \
-      dart::Expect(__FILE__, __LINE__)                                         \
-          .Fail("parse unexpectedly failed at \"%s\": %" Pd ": %s",            \
-                parser.Input() + parser.error_pos(), parser.error_pos(),       \
-                parser.error_message());                                       \
-    }                                                                          \
-  } while (false);
-
-static const char* const shared_sexp_cstr =
-    "(def v0 (Constant 3) { type (CompileType 147 { nullable false, name "
-    "\"T{Smi}\"}), })";
-
-static void CheckDeserializedSExpParts(SExpression* sexp) {
-  EXPECT_NOTNULL(sexp);
-  EXPECT(sexp->IsList());
-  SExpList* list = sexp->AsList();
-  EXPECT_EQ(3, list->Length());
-  EXPECT_NOTNULL(list->At(0));
-  EXPECT(list->At(0)->IsSymbol());
-  EXPECT_STREQ("def", list->At(0)->AsSymbol()->value());
-  EXPECT_NOTNULL(list->At(1));
-  EXPECT(list->At(1)->IsSymbol());
-  EXPECT_STREQ("v0", list->At(1)->AsSymbol()->value());
-  EXPECT_NOTNULL(list->At(2));
-  EXPECT(list->At(2)->IsList());
-
-  SExpList* sublist = list->At(2)->AsList();
-  EXPECT_EQ(2, sublist->Length());
-  EXPECT_NOTNULL(sublist->At(0));
-  EXPECT(sublist->At(0)->IsSymbol());
-  EXPECT_STREQ("Constant", sublist->At(0)->AsSymbol()->value());
-  EXPECT_NOTNULL(sublist->At(1));
-  EXPECT(sublist->At(1)->IsInteger());
-  EXPECT_EQ(3, sublist->At(1)->AsInteger()->value());
-  EXPECT_EQ(0, sublist->ExtraLength());
-
-  EXPECT_EQ(1, list->ExtraLength());
-  EXPECT(list->ExtraHasKey("type"));
-  EXPECT(list->ExtraLookupValue("type")->IsList());
-
-  SExpList* ctype = list->ExtraLookupValue("type")->AsList();
-  EXPECT_EQ(2, ctype->Length());
-  EXPECT_NOTNULL(ctype->At(0));
-  EXPECT(ctype->At(0)->IsSymbol());
-  EXPECT_STREQ("CompileType", ctype->At(0)->AsSymbol()->value());
-  EXPECT_NOTNULL(ctype->At(1));
-  EXPECT(ctype->At(1)->IsInteger());
-  EXPECT_EQ(147, ctype->At(1)->AsInteger()->value());
-
-  EXPECT_EQ(2, ctype->ExtraLength());
-  EXPECT(ctype->ExtraHasKey("nullable"));
-  EXPECT(ctype->ExtraLookupValue("nullable")->IsBool());
-  EXPECT(!ctype->ExtraLookupValue("nullable")->AsBool()->value());
-  EXPECT(ctype->ExtraHasKey("name"));
-  EXPECT(ctype->ExtraLookupValue("name")->IsString());
-  EXPECT_STREQ(ctype->ExtraLookupValue("name")->AsString()->value(), "T{Smi}");
-}
-
-ISOLATE_UNIT_TEST_CASE(DeserializeSExp) {
-  Zone* const zone = Thread::Current()->zone();
-  SExpression* sexp = SExpression::FromCString(zone, shared_sexp_cstr);
-  CheckDeserializedSExpParts(sexp);
-
-  // Treating escaped backslash appropriately so string is terminated.
-  {
-    const char* const cstr = "(def v0 (Constant 3) { foo \"123\\\\\" })";
-    SExpParser parser(zone, cstr, strlen(cstr));
-    SExpression* const sexp = parser.Parse();
-    EXPECT_SEXP_PARSE_SUCCESS(sexp, parser);
-    EXPECT(sexp->IsList());
-    EXPECT_EQ(1, sexp->AsList()->ExtraLength());
-    EXPECT(sexp->AsList()->ExtraHasKey("foo"));
-    auto val = sexp->AsList()->ExtraLookupValue("foo");
-    EXPECT(val->IsString());
-    EXPECT_STREQ("123\\", val->AsString()->value());
-  }
-  // Valid unicode escapes are properly handled.
-  {
-    const char* const cstr =
-        "(def v0 (Constant 3) { foo \"\\u0001\\u0020\\u0054\" })";
-    SExpParser parser(zone, cstr, strlen(cstr));
-    SExpression* const sexp = parser.Parse();
-    EXPECT_SEXP_PARSE_SUCCESS(sexp, parser);
-    EXPECT(sexp->IsList());
-    EXPECT_EQ(1, sexp->AsList()->ExtraLength());
-    EXPECT(sexp->AsList()->ExtraHasKey("foo"));
-    auto val = sexp->AsList()->ExtraLookupValue("foo");
-    EXPECT(val->IsString());
-    EXPECT_STREQ("\x01 T", val->AsString()->value());
-  }
-}
-
-ISOLATE_UNIT_TEST_CASE(DeserializeSExpNumbers) {
-  Zone* const zone = Thread::Current()->zone();
-
-  // Negative integers are handled.
-  {
-    const char* const cstr = "(-4 -50 -1414243)";
-    SExpParser parser(zone, cstr, strlen(cstr));
-    SExpression* const sexp = parser.Parse();
-    EXPECT_SEXP_PARSE_SUCCESS(sexp, parser);
-    EXPECT(sexp->IsList());
-    auto list = sexp->AsList();
-    EXPECT_EQ(3, list->Length());
-    EXPECT_EQ(0, list->ExtraLength());
-    for (intptr_t i = 0; i < list->Length(); i++) {
-      EXPECT(list->At(i)->IsInteger());
-      EXPECT(list->At(i)->AsInteger()->value() < 0);
-    }
-  }
-
-  // Various decimal/exponent Doubles are appropriately handled.
-  {
-    const char* const cstr = "(1.05 0.05 .03 1e100 1e-100)";
-    SExpParser parser(zone, cstr, strlen(cstr));
-    SExpression* const sexp = parser.Parse();
-    EXPECT_SEXP_PARSE_SUCCESS(sexp, parser);
-    EXPECT(sexp->IsList());
-    auto list = sexp->AsList();
-    EXPECT_EQ(5, list->Length());
-    EXPECT_EQ(0, list->ExtraLength());
-    EXPECT(list->At(0)->IsDouble());
-    double val = list->At(0)->AsDouble()->value();
-    EXPECT(val > 1.04 && val < 1.06);
-    EXPECT(list->At(1)->IsDouble());
-    val = list->At(1)->AsDouble()->value();
-    EXPECT(val > 0.04 && val < 0.06);
-    EXPECT(list->At(2)->IsDouble());
-    val = list->At(2)->AsDouble()->value();
-    EXPECT(val > 0.02 && val < 0.04);
-    EXPECT(list->At(3)->IsDouble());
-    val = list->At(3)->AsDouble()->value();
-    EXPECT(val > 0.9e100 && val < 1.1e100);
-    EXPECT(list->At(4)->IsDouble());
-    val = list->At(4)->AsDouble()->value();
-    EXPECT(val > 0.9e-100 && val < 1.1e-100);
-  }
-
-  // Special Double symbols are appropriately handled.
-  {
-    const char* const cstr = "(NaN Infinity -Infinity)";
-    SExpParser parser(zone, cstr, strlen(cstr));
-    SExpression* const sexp = parser.Parse();
-    EXPECT_SEXP_PARSE_SUCCESS(sexp, parser);
-    EXPECT(sexp->IsList());
-    auto list = sexp->AsList();
-    EXPECT_EQ(3, list->Length());
-    EXPECT_EQ(0, list->ExtraLength());
-    EXPECT(list->At(0)->IsDouble());
-    double val = list->At(0)->AsDouble()->value();
-    EXPECT(isnan(val));
-    EXPECT(list->At(1)->IsDouble());
-    val = list->At(1)->AsDouble()->value();
-    EXPECT(val > 0.0);
-    EXPECT(isinf(val));
-    EXPECT(list->At(2)->IsDouble());
-    val = list->At(2)->AsDouble()->value();
-    EXPECT(val < 0.0);
-    EXPECT(isinf(val));
-  }
-}
-
-ISOLATE_UNIT_TEST_CASE(DeserializeSExpRoundTrip) {
-  Zone* const zone = Thread::Current()->zone();
-  SExpression* sexp = SExpression::FromCString(zone, shared_sexp_cstr);
-
-  TextBuffer buf(100);
-  sexp->SerializeTo(zone, &buf, "", 9999);
-  SExpression* round_trip = SExpression::FromCString(zone, buf.buffer());
-  CheckDeserializedSExpParts(round_trip);
-  EXPECT(sexp->Equals(round_trip));
-
-  char* const old_serialization = buf.Steal();
-  round_trip->SerializeTo(zone, &buf, "", 9999);
-  char* const new_serialization = buf.buffer();
-  EXPECT_STREQ(old_serialization, new_serialization);
-  free(old_serialization);
-}
-
-ISOLATE_UNIT_TEST_CASE(DeserializeSExpMapsJoined) {
-  Zone* const zone = Thread::Current()->zone();
-  // Same as shared_sexp_cstr except we split the map on the CompileType into
-  // two parts.
-  const char* const cstr =
-      "(def v0 (Constant 3) { type (CompileType { nullable false } 147 { name "
-      "\"T{Smi}\"}), })";
-  SExpression* sexp = SExpression::FromCString(zone, cstr);
-  CheckDeserializedSExpParts(sexp);
-}
-
-ISOLATE_UNIT_TEST_CASE(DeserializeSExpFailures) {
-  Zone* const zone = Thread::Current()->zone();
-  // Unterminated s-exp list
-  {
-    const char* const before_start = "(def v0 ";
-    const char* const after_start = "(Constant 3";
-    const char* const cstr =
-        OS::SCreate(zone, "%s%s", before_start, after_start);
-    const intptr_t start_pos = strlen(before_start);
-    const intptr_t error_pos = strlen(cstr);
-    SExpParser parser(zone, cstr, strlen(cstr));
-    SExpression* const sexp = parser.Parse();
-    const char* const expected_message =
-        OS::SCreate(zone, SExpParser::ErrorStrings::kOpenSExpList, start_pos);
-    EXPECT_SEXP_PARSE_ERROR(sexp, parser, error_pos, expected_message);
-  }
-  // Non-symbol label in map pair
-  {
-    const char* const before_error = "(def v0 (Constant 3) { ";
-    const intptr_t error_pos = strlen(before_error);
-    const char* const error = "3 4 })";
-    const char* const cstr = OS::SCreate(zone, "%s%s", before_error, error);
-    SExpParser parser(zone, cstr, strlen(cstr));
-    SExpression* const sexp = parser.Parse();
-    const char* const expected_message =
-        SExpParser::ErrorStrings::kNonSymbolLabel;
-    EXPECT_SEXP_PARSE_ERROR(sexp, parser, error_pos, expected_message);
-  }
-  // No values in a map pair
-  {
-    const char* const label = "foo";
-    const char* const before_error =
-        OS::SCreate(zone, "(def v0 (Constant 3) { %s ", label);
-    const intptr_t error_pos = strlen(before_error);
-    const char* const error = "})";
-    const char* const cstr = OS::SCreate(zone, "%s%s", before_error, error);
-    SExpParser parser(zone, cstr, strlen(cstr));
-    SExpression* const sexp = parser.Parse();
-    const char* const expected_message =
-        OS::SCreate(zone, SExpParser::ErrorStrings::kNoMapValue, label);
-    EXPECT_SEXP_PARSE_ERROR(sexp, parser, error_pos, expected_message);
-  }
-  // Multiple values in a map pair
-  {
-    const char* const label = "foo";
-    const char* const before_error =
-        OS::SCreate(zone, "(def v0 (Constant 3) { %s 4 ", label);
-    const intptr_t error_pos = strlen(before_error);
-    const char* const error = "5, })";
-    const char* const cstr = OS::SCreate(zone, "%s%s", before_error, error);
-    SExpParser parser(zone, cstr, strlen(cstr));
-    SExpression* const sexp = parser.Parse();
-    const char* const expected_message =
-        OS::SCreate(zone, SExpParser::ErrorStrings::kExtraMapValue, label);
-    EXPECT_SEXP_PARSE_ERROR(sexp, parser, error_pos, expected_message);
-  }
-  // Unterminated quoted string
-  {
-    const char* const before_string =
-        OS::SCreate(zone, "(def v0 (Constant 3) { foo ");
-    const intptr_t string_pos = strlen(before_string);
-    const char* const error = "\"abc })";
-    const char* const cstr = OS::SCreate(zone, "%s%s", before_string, error);
-    const intptr_t error_pos = strlen(cstr);
-    SExpParser parser(zone, cstr, strlen(cstr));
-    SExpression* const sexp = parser.Parse();
-    const char* const expected_message =
-        OS::SCreate(zone, SExpParser::ErrorStrings::kOpenString, string_pos);
-    EXPECT_SEXP_PARSE_ERROR(sexp, parser, error_pos, expected_message);
-  }
-  // Unterminated extra info map
-  {
-    const char* const before_map = "(def v0 (Constant 3) ";
-    const intptr_t map_pos = strlen(before_map);
-    const char* const map_start = "{ foo 3, ";
-    const char* const before_error =
-        OS::SCreate(zone, "%s%s", before_map, map_start);
-    const intptr_t error_pos = strlen(before_error);
-    const char* const error = ")";
-    const char* const cstr = OS::SCreate(zone, "%s%s", before_error, error);
-    SExpParser parser(zone, cstr, strlen(cstr));
-    SExpression* const sexp = parser.Parse();
-    const char* const expected_message =
-        OS::SCreate(zone, SExpParser::ErrorStrings::kOpenMap, map_pos);
-    EXPECT_SEXP_PARSE_ERROR(sexp, parser, error_pos, expected_message);
-  }
-  // Repeated extra info map label
-  {
-    const char* const label = "foo";
-    const char* const before_error =
-        OS::SCreate(zone, "(def v0 (Constant 3) { %s 3, ", label);
-    const intptr_t error_pos = strlen(before_error);
-    const char* const error = OS::SCreate(zone, "%s 4, })", label);
-    const char* const cstr = OS::SCreate(zone, "%s%s", before_error, error);
-    SExpParser parser(zone, cstr, strlen(cstr));
-    SExpression* const sexp = parser.Parse();
-    const char* const expected_message =
-        OS::SCreate(zone, SExpParser::ErrorStrings::kRepeatedMapLabel, label);
-    EXPECT_SEXP_PARSE_ERROR(sexp, parser, error_pos, expected_message);
-  }
-  // Unicode escape with non-hex digits.
-  {
-    const char* const before_error = "(def v0 (Constant 3) { foo \"123";
-    const intptr_t error_pos = strlen(before_error);
-    const char* const error = "\\u12FG\" })";
-    const char* const cstr = OS::SCreate(zone, "%s%s", before_error, error);
-    SExpParser parser(zone, cstr, strlen(cstr));
-    SExpression* const sexp = parser.Parse();
-    const char* const expected_message =
-        SExpParser::ErrorStrings::kBadUnicodeEscape;
-    EXPECT_SEXP_PARSE_ERROR(sexp, parser, error_pos, expected_message);
-  }
-  // Unicode escape with less than four hex digits.
-  {
-    const char* const before_error = "(def v0 (Constant 3) { foo \"123";
-    const intptr_t error_pos = strlen(before_error);
-    const char* const error = "\\u12\" })";
-    const char* const cstr = OS::SCreate(zone, "%s%s", before_error, error);
-    SExpParser parser(zone, cstr, strlen(cstr));
-    SExpression* const sexp = parser.Parse();
-    const char* const expected_message =
-        SExpParser::ErrorStrings::kBadUnicodeEscape;
-    EXPECT_SEXP_PARSE_ERROR(sexp, parser, error_pos, expected_message);
-  }
-  // Treating backslashed quote appropriately to detect unterminated string
-  {
-    const char* const before_string = "(def v0 (Constant 3) { foo ";
-    const intptr_t string_pos = strlen(before_string);
-    const char* const error = "\"123\\\" })";
-    const char* const cstr = OS::SCreate(zone, "%s%s", before_string, error);
-    const intptr_t error_pos = strlen(cstr);
-    SExpParser parser(zone, cstr, strlen(cstr));
-    SExpression* const sexp = parser.Parse();
-    const char* const expected_message =
-        OS::SCreate(zone, SExpParser::ErrorStrings::kOpenString, string_pos);
-    EXPECT_SEXP_PARSE_ERROR(sexp, parser, error_pos, expected_message);
-  }
-}
-
-}  // namespace dart
diff --git a/runtime/vm/compiler/compiler_pass.cc b/runtime/vm/compiler/compiler_pass.cc
index 2a6f91f..1dfcdce 100644
--- a/runtime/vm/compiler/compiler_pass.cc
+++ b/runtime/vm/compiler/compiler_pass.cc
@@ -8,9 +8,7 @@
 #include "vm/compiler/backend/branch_optimizer.h"
 #include "vm/compiler/backend/constant_propagator.h"
 #include "vm/compiler/backend/flow_graph_checker.h"
-#include "vm/compiler/backend/il_deserializer.h"
 #include "vm/compiler/backend/il_printer.h"
-#include "vm/compiler/backend/il_serializer.h"
 #include "vm/compiler/backend/inliner.h"
 #include "vm/compiler/backend/linearscan.h"
 #include "vm/compiler/backend/range_analysis.h"
@@ -80,14 +78,6 @@
                       "List of comma separated compilation passes flags. "
                       "Use -Name to disable a pass, Name to print IL after it. "
                       "Do --compiler-passes=help for more information.");
-DEFINE_FLAG(bool,
-            early_round_trip_serialization,
-            false,
-            "Perform early round trip serialization compiler pass.");
-DEFINE_FLAG(bool,
-            late_round_trip_serialization,
-            false,
-            "Perform late round trip serialization compiler pass.");
 DECLARE_FLAG(bool, print_flow_graph);
 DECLARE_FLAG(bool, print_flow_graph_optimized);
 
@@ -286,9 +276,6 @@
     PipelineMode mode,
     CompilerPassState* pass_state) {
   INVOKE_PASS(ComputeSSA);
-  if (FLAG_early_round_trip_serialization) {
-    INVOKE_PASS(RoundTripSerialization);
-  }
   INVOKE_PASS(SetOuterInliningId);
   INVOKE_PASS(TypePropagation);
   INVOKE_PASS(Canonicalize);
@@ -309,10 +296,6 @@
   INVOKE_PASS_AOT(DelayAllocations);
   INVOKE_PASS(EliminateWriteBarriers);
   INVOKE_PASS(FinalizeGraph);
-  INVOKE_PASS_AOT(SerializeGraph);
-  if (FLAG_late_round_trip_serialization) {
-    INVOKE_PASS(RoundTripSerialization);
-  }
   INVOKE_PASS(AllocateRegisters);
   INVOKE_PASS(ReorderBlocks);
   return pass_state->flow_graph();
@@ -321,9 +304,6 @@
 FlowGraph* CompilerPass::RunPipeline(PipelineMode mode,
                                      CompilerPassState* pass_state) {
   INVOKE_PASS(ComputeSSA);
-  if (FLAG_early_round_trip_serialization) {
-    INVOKE_PASS(RoundTripSerialization);
-  }
   INVOKE_PASS_AOT(ApplyClassIds);
   INVOKE_PASS_AOT(TypePropagation);
   INVOKE_PASS(ApplyICData);
@@ -382,12 +362,6 @@
   INVOKE_PASS(AllocationSinking_DetachMaterializations);
   INVOKE_PASS(EliminateWriteBarriers);
   INVOKE_PASS(FinalizeGraph);
-  // If we are serializing the flow graph, do it now before we start
-  // doing register allocation.
-  INVOKE_PASS_AOT(SerializeGraph);
-  if (FLAG_late_round_trip_serialization) {
-    INVOKE_PASS(RoundTripSerialization);
-  }
   INVOKE_PASS(AllocateRegisters);
   INVOKE_PASS(ReorderBlocks);
   return pass_state->flow_graph();
@@ -576,27 +550,4 @@
   flow_graph->RemoveRedefinitions();
 });
 
-#if defined(DART_PRECOMPILER)
-COMPILER_PASS(SerializeGraph, {
-  if (state->precompiler == nullptr) return false;
-  if (auto stream = state->precompiler->il_serialization_stream()) {
-    auto file_write = Dart::file_write_callback();
-    ASSERT(file_write != nullptr);
-
-    const intptr_t kInitialBufferSize = 1 * MB;
-    TextBuffer buffer(kInitialBufferSize);
-    StackZone stack_zone(Thread::Current());
-    FlowGraphSerializer::SerializeToBuffer(stack_zone.GetZone(), flow_graph,
-                                           &buffer);
-
-    file_write(buffer.buffer(), buffer.length(), stream);
-  }
-});
-#endif
-
-COMPILER_PASS(RoundTripSerialization, {
-  FlowGraphDeserializer::RoundTripSerialization(state);
-  ASSERT(state->flow_graph() != nullptr);
-})
-
 }  // namespace dart
diff --git a/runtime/vm/compiler/compiler_pass.h b/runtime/vm/compiler/compiler_pass.h
index 1904561..39dc9bd 100644
--- a/runtime/vm/compiler/compiler_pass.h
+++ b/runtime/vm/compiler/compiler_pass.h
@@ -44,9 +44,7 @@
   V(OptimizeTypedDataAccesses)                                                 \
   V(RangeAnalysis)                                                             \
   V(ReorderBlocks)                                                             \
-  V(RoundTripSerialization)                                                    \
   V(SelectRepresentations)                                                     \
-  V(SerializeGraph)                                                            \
   V(SetOuterInliningId)                                                        \
   V(TryCatchOptimization)                                                      \
   V(TryOptimizePatterns)                                                       \
diff --git a/runtime/vm/compiler/compiler_sources.gni b/runtime/vm/compiler/compiler_sources.gni
index edfa863..8cc4b39 100644
--- a/runtime/vm/compiler/compiler_sources.gni
+++ b/runtime/vm/compiler/compiler_sources.gni
@@ -57,13 +57,9 @@
   "backend/il.h",
   "backend/il_arm.cc",
   "backend/il_arm64.cc",
-  "backend/il_deserializer.cc",
-  "backend/il_deserializer.h",
   "backend/il_ia32.cc",
   "backend/il_printer.cc",
   "backend/il_printer.h",
-  "backend/il_serializer.cc",
-  "backend/il_serializer.h",
   "backend/il_x64.cc",
   "backend/inliner.cc",
   "backend/inliner.h",
@@ -79,8 +75,6 @@
   "backend/range_analysis.h",
   "backend/redundancy_elimination.cc",
   "backend/redundancy_elimination.h",
-  "backend/sexpression.cc",
-  "backend/sexpression.h",
   "backend/slot.cc",
   "backend/slot.h",
   "backend/type_propagator.cc",
@@ -175,7 +169,6 @@
   "backend/range_analysis_test.cc",
   "backend/reachability_fence_test.cc",
   "backend/redundancy_elimination_test.cc",
-  "backend/sexpression_test.cc",
   "backend/slot_test.cc",
   "backend/type_propagator_test.cc",
   "backend/typed_data_aot_test.cc",
diff --git a/runtime/vm/dart.cc b/runtime/vm/dart.cc
index 65332f5..3835109 100644
--- a/runtime/vm/dart.cc
+++ b/runtime/vm/dart.cc
@@ -53,10 +53,6 @@
 DEFINE_FLAG(bool, trace_shutdown, false, "Trace VM shutdown on stderr");
 DECLARE_FLAG(bool, strong);
 
-#if defined(DART_PRECOMPILED_RUNTIME)
-DEFINE_FLAG(bool, print_llvm_constant_pool, false, "Print LLVM constant pool");
-#endif
-
 Isolate* Dart::vm_isolate_ = NULL;
 int64_t Dart::start_time_micros_ = 0;
 ThreadPool* Dart::thread_pool_ = NULL;
@@ -811,52 +807,6 @@
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 }
 
-#if defined(DART_PRECOMPILED_RUNTIME)
-static void PrintLLVMConstantPool(Thread* T, Isolate* I) {
-  StackZone printing_zone(T);
-  HandleScope printing_scope(T);
-  TextBuffer b(1000);
-  const auto& constants = GrowableObjectArray::Handle(
-      I->group()->object_store()->llvm_constant_pool());
-  if (constants.IsNull()) {
-    b.AddString("No constant pool information in snapshot.\n\n");
-  } else {
-    auto const len = constants.Length();
-    b.Printf("Constant pool contents (length %" Pd "):\n", len);
-    auto& obj = Object::Handle();
-    for (intptr_t i = 0; i < len; i++) {
-      obj = constants.At(i);
-      b.Printf("  %5" Pd ": ", i);
-      if (obj.IsString()) {
-        b.AddChar('"');
-        b.AddEscapedString(obj.ToCString());
-        b.AddChar('"');
-      } else {
-        b.AddString(obj.ToCString());
-      }
-      b.AddChar('\n');
-    }
-    b.AddString("End of constant pool.\n\n");
-  }
-  const auto& functions = GrowableObjectArray::Handle(
-      I->group()->object_store()->llvm_function_pool());
-  if (functions.IsNull()) {
-    b.AddString("No function pool information in snapshot.\n\n");
-  } else {
-    auto const len = functions.Length();
-    b.Printf("Function pool contents (length %" Pd "):\n", len);
-    auto& obj = Function::Handle();
-    for (intptr_t i = 0; i < len; i++) {
-      obj ^= functions.At(i);
-      ASSERT(!obj.IsNull());
-      b.Printf("  %5" Pd ": %s\n", i, obj.ToFullyQualifiedCString());
-    }
-    b.AddString("End of function pool.\n\n");
-  }
-  THR_Print("%s", b.buffer());
-}
-#endif
-
 ErrorPtr Dart::InitializeIsolate(const uint8_t* snapshot_data,
                                  const uint8_t* snapshot_instructions,
                                  const uint8_t* kernel_buffer,
@@ -913,11 +863,6 @@
 #if !defined(TARGET_ARCH_IA32)
     ASSERT(IG->object_store()->build_method_extractor_code() != Code::null());
 #endif
-#if defined(DART_PRECOMPILED_RUNTIME)
-    if (FLAG_print_llvm_constant_pool) {
-      PrintLLVMConstantPool(T, I);
-    }
-#endif  // defined(DART_PRECOMPILED_RUNTIME)
   } else {
 #if !defined(TARGET_ARCH_IA32)
     if (I != Dart::vm_isolate()) {
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 19f8743..cdda785 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -2256,8 +2256,6 @@
   }
 
  private:
-  friend class FlowGraphSerializer;  // For is_megamorphic()
-
   static ICDataPtr New();
 
   // Grows the array and also sets the argument to the index that should be used
diff --git a/runtime/vm/object_store.h b/runtime/vm/object_store.h
index 7554f4d..55f8b6d 100644
--- a/runtime/vm/object_store.h
+++ b/runtime/vm/object_store.h
@@ -169,9 +169,6 @@
   RW(Function, complete_on_async_return)                                       \
   RW(Function, complete_on_async_error)                                        \
   RW(Class, async_star_stream_controller)                                      \
-  RW(GrowableObjectArray, llvm_constant_pool)                                  \
-  RW(GrowableObjectArray, llvm_function_pool)                                  \
-  RW(Array, llvm_constant_hash_table)                                          \
   RW(CompressedStackMaps, canonicalized_stack_map_entries)                     \
   RW(ObjectPool, global_object_pool)                                           \
   RW(Array, unique_dynamic_targets)                                            \
diff --git a/tools/VERSION b/tools/VERSION
index 8f43000..cf2e335 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 13
 PATCH 0
-PRERELEASE 123
+PRERELEASE 124
 PRERELEASE_PATCH 0
\ No newline at end of file