diff --git a/runtime/tests/vm/dart/splay_test.dart b/runtime/tests/vm/dart/splay_test.dart
index ef51ede..25b7d98 100644
--- a/runtime/tests/vm/dart/splay_test.dart
+++ b/runtime/tests/vm/dart/splay_test.dart
@@ -31,6 +31,7 @@
 // VMOptions=--no_load_cse
 // VMOptions=--no_dead_store_elimination
 // VMOptions=--no_load_cse --no_dead_store_elimination
+// VMOptions=--test_il_serialization
 
 import "dart:math";
 import 'package:benchmark_harness/benchmark_harness.dart';
diff --git a/runtime/tests/vm/dart_2/splay_test.dart b/runtime/tests/vm/dart_2/splay_test.dart
index 6cd3050..d6a349f 100644
--- a/runtime/tests/vm/dart_2/splay_test.dart
+++ b/runtime/tests/vm/dart_2/splay_test.dart
@@ -35,6 +35,7 @@
 // VMOptions=--no_load_cse
 // VMOptions=--no_dead_store_elimination
 // VMOptions=--no_load_cse --no_dead_store_elimination
+// VMOptions=--test_il_serialization
 
 import "dart:math";
 import 'package:benchmark_harness/benchmark_harness.dart';
diff --git a/runtime/vm/bitmap.cc b/runtime/vm/bitmap.cc
index 06119e3..a79912af 100644
--- a/runtime/vm/bitmap.cc
+++ b/runtime/vm/bitmap.cc
@@ -149,4 +149,26 @@
   }
 }
 
+void BitmapBuilder::Write(BaseWriteStream* stream) const {
+  const intptr_t payload_size =
+      Utils::Minimum(Utils::RoundUp(Length(), kBitsPerByte) / kBitsPerByte,
+                     data_size_in_bytes_);
+  stream->Write<intptr_t>(Length());
+  stream->Write<intptr_t>(payload_size);
+  stream->WriteBytes(BackingStore(), payload_size);
+}
+
+void BitmapBuilder::Read(ReadStream* stream) {
+  length_ = stream->Read<intptr_t>();
+  const intptr_t payload_size = stream->Read<intptr_t>();
+  if (payload_size > data_size_in_bytes_) {
+    data_size_in_bytes_ = payload_size;
+    data_.ptr_ = AllocBackingStore(data_size_in_bytes_);
+  } else {
+    memset(BackingStore() + payload_size, 0,
+           data_size_in_bytes_ - payload_size);
+  }
+  stream->ReadBytes(BackingStore(), payload_size);
+}
+
 }  // namespace dart
diff --git a/runtime/vm/bitmap.h b/runtime/vm/bitmap.h
index 74c4c5b..2c18ba5 100644
--- a/runtime/vm/bitmap.h
+++ b/runtime/vm/bitmap.h
@@ -54,6 +54,9 @@
   void Print() const;
   void AppendAsBytesTo(BaseWriteStream* stream) const;
 
+  void Write(BaseWriteStream* stream) const;
+  void Read(ReadStream* stream);
+
  private:
   static constexpr intptr_t kIncrementSizeInBytes = 16;
   static constexpr intptr_t kInlineCapacityInBytes = 16;
diff --git a/runtime/vm/code_descriptors.h b/runtime/vm/code_descriptors.h
index 47ced6f..6ca2430 100644
--- a/runtime/vm/code_descriptors.h
+++ b/runtime/vm/code_descriptors.h
@@ -107,7 +107,7 @@
     ASSERT(list_[try_index].pc_offset == ExceptionHandlers::kInvalidPcOffset);
     list_[try_index].pc_offset = pc_offset;
     list_[try_index].is_generated = is_generated;
-    ASSERT(handler_types.IsZoneHandle());
+    ASSERT(handler_types.IsNotTemporaryScopedHandle());
     list_[try_index].handler_types = &handler_types;
     list_[try_index].needs_stacktrace |= needs_stacktrace;
   }
diff --git a/runtime/vm/compiler/aot/dispatch_table_generator.cc b/runtime/vm/compiler/aot/dispatch_table_generator.cc
index bb5faac..1245c38 100644
--- a/runtime/vm/compiler/aot/dispatch_table_generator.cc
+++ b/runtime/vm/compiler/aot/dispatch_table_generator.cc
@@ -375,6 +375,10 @@
 const TableSelector* SelectorMap::GetSelector(
     const Function& interface_target) const {
   const int32_t sid = SelectorId(interface_target);
+  return GetSelector(sid);
+}
+
+const TableSelector* SelectorMap::GetSelector(int32_t sid) const {
   if (sid == kInvalidSelectorId) return nullptr;
   const TableSelector* selector = &selectors_[sid];
   if (!selector->IsUsed()) return nullptr;
diff --git a/runtime/vm/compiler/aot/dispatch_table_generator.h b/runtime/vm/compiler/aot/dispatch_table_generator.h
index e916a3c..770d880 100644
--- a/runtime/vm/compiler/aot/dispatch_table_generator.h
+++ b/runtime/vm/compiler/aot/dispatch_table_generator.h
@@ -61,6 +61,8 @@
   // not have a selector assigned.
   const TableSelector* GetSelector(const Function& interface_target) const;
 
+  const TableSelector* GetSelector(int32_t sid) const;
+
  private:
   static const int32_t kInvalidSelectorId =
       kernel::ProcedureAttributesMetadata::kInvalidSelectorId;
diff --git a/runtime/vm/compiler/backend/compile_type.h b/runtime/vm/compiler/backend/compile_type.h
index 1eeb89c..bc9c6e5 100644
--- a/runtime/vm/compiler/backend/compile_type.h
+++ b/runtime/vm/compiler/backend/compile_type.h
@@ -18,6 +18,8 @@
 class AbstractType;
 class BaseTextBuffer;
 class Definition;
+class FlowGraphDeserializer;
+class FlowGraphSerializer;
 
 template <typename T>
 class GrowableArray;
@@ -281,6 +283,9 @@
   void set_owner(Definition* owner) { owner_ = owner; }
   Definition* owner() const { return owner_; }
 
+  void Write(FlowGraphSerializer* s) const;
+  explicit CompileType(FlowGraphDeserializer* d);
+
  private:
   bool can_be_null_;
   bool can_be_sentinel_;
diff --git a/runtime/vm/compiler/backend/flow_graph.cc b/runtime/vm/compiler/backend/flow_graph.cc
index fbefe32..2459014 100644
--- a/runtime/vm/compiler/backend/flow_graph.cc
+++ b/runtime/vm/compiler/backend/flow_graph.cc
@@ -2896,4 +2896,120 @@
   FlowGraphPrinter::PrintGraph(phase, this);
 }
 
+class SSACompactor : public ValueObject {
+ public:
+  SSACompactor(intptr_t num_blocks,
+               intptr_t num_ssa_vars,
+               ZoneGrowableArray<Definition*>* detached_defs)
+      : block_num_(num_blocks),
+        ssa_num_(num_ssa_vars),
+        detached_defs_(detached_defs) {
+    block_num_.EnsureLength(num_blocks, -1);
+    ssa_num_.EnsureLength(num_ssa_vars, -1);
+  }
+
+  void RenumberGraph(FlowGraph* graph) {
+    for (auto block : graph->reverse_postorder()) {
+      block_num_[block->block_id()] = 1;
+      CollectDetachedMaterializations(block->env());
+
+      if (auto* block_with_idefs = block->AsBlockEntryWithInitialDefs()) {
+        for (Definition* def : *block_with_idefs->initial_definitions()) {
+          RenumberDefinition(def);
+          CollectDetachedMaterializations(def->env());
+        }
+      }
+      if (auto* join = block->AsJoinEntry()) {
+        for (PhiIterator it(join); !it.Done(); it.Advance()) {
+          RenumberDefinition(it.Current());
+        }
+      }
+      for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
+        Instruction* instr = it.Current();
+        if (Definition* def = instr->AsDefinition()) {
+          RenumberDefinition(def);
+        }
+        CollectDetachedMaterializations(instr->env());
+      }
+    }
+    for (auto* def : (*detached_defs_)) {
+      RenumberDefinition(def);
+    }
+    graph->set_current_ssa_temp_index(current_ssa_index_);
+
+    // Preserve order between block ids to as predecessors are sorted
+    // by block ids.
+    intptr_t current_block_index = 0;
+    for (intptr_t i = 0, n = block_num_.length(); i < n; ++i) {
+      if (block_num_[i] >= 0) {
+        block_num_[i] = current_block_index++;
+      }
+    }
+    for (auto block : graph->reverse_postorder()) {
+      block->set_block_id(block_num_[block->block_id()]);
+    }
+    graph->set_max_block_id(current_block_index - 1);
+  }
+
+ private:
+  void RenumberDefinition(Definition* def) {
+    if (def->HasSSATemp()) {
+      const intptr_t old_index = def->ssa_temp_index();
+      intptr_t new_index = ssa_num_[old_index];
+      if (new_index < 0) {
+        ssa_num_[old_index] = new_index = current_ssa_index_++;
+      }
+      def->set_ssa_temp_index(new_index);
+    }
+  }
+
+  bool IsDetachedDefinition(Definition* def) {
+    return def->IsMaterializeObject() && (def->next() == nullptr);
+  }
+
+  void AddDetachedDefinition(Definition* def) {
+    for (intptr_t i = 0, n = detached_defs_->length(); i < n; ++i) {
+      if ((*detached_defs_)[i] == def) {
+        return;
+      }
+    }
+    detached_defs_->Add(def);
+    // Follow inputs as detached definitions can reference other
+    // detached definitions.
+    for (intptr_t i = 0, n = def->InputCount(); i < n; ++i) {
+      Definition* input = def->InputAt(i)->definition();
+      if (IsDetachedDefinition(input)) {
+        AddDetachedDefinition(input);
+      }
+    }
+    ASSERT(def->env() == nullptr);
+  }
+
+  void CollectDetachedMaterializations(Environment* env) {
+    if (env == nullptr) {
+      return;
+    }
+    for (Environment::DeepIterator it(env); !it.Done(); it.Advance()) {
+      Definition* def = it.CurrentValue()->definition();
+      if (IsDetachedDefinition(def)) {
+        AddDetachedDefinition(def);
+      }
+    }
+  }
+
+  GrowableArray<intptr_t> block_num_;
+  GrowableArray<intptr_t> ssa_num_;
+  intptr_t current_ssa_index_ = 0;
+  ZoneGrowableArray<Definition*>* detached_defs_;
+};
+
+void FlowGraph::CompactSSA(ZoneGrowableArray<Definition*>* detached_defs) {
+  if (detached_defs == nullptr) {
+    detached_defs = new (Z) ZoneGrowableArray<Definition*>(Z, 0);
+  }
+  SSACompactor compactor(max_block_id() + 1, current_ssa_temp_index(),
+                         detached_defs);
+  compactor.RenumberGraph(this);
+}
+
 }  // namespace dart
diff --git a/runtime/vm/compiler/backend/flow_graph.h b/runtime/vm/compiler/backend/flow_graph.h
index 354e15f..354e2fa 100644
--- a/runtime/vm/compiler/backend/flow_graph.h
+++ b/runtime/vm/compiler/backend/flow_graph.h
@@ -208,6 +208,9 @@
   const GrowableArray<BlockEntryInstr*>& reverse_postorder() const {
     return reverse_postorder_;
   }
+  const GrowableArray<BlockEntryInstr*>& optimized_block_order() const {
+    return optimized_block_order_;
+  }
   static bool ShouldReorderBlocks(const Function& function, bool is_optimized);
   GrowableArray<BlockEntryInstr*>* CodegenBlockOrder(bool is_optimized);
 
@@ -533,6 +536,14 @@
   const Array& coverage_array() const { return *coverage_array_; }
   void set_coverage_array(const Array& array) { coverage_array_ = &array; }
 
+  // Renumbers SSA values and basic blocks to make numbering dense.
+  // Preserves order among block ids.
+  //
+  // Also collects definitions which are detached from the flow graph
+  // but still referenced (currently only MaterializeObject instructions
+  // can be detached).
+  void CompactSSA(ZoneGrowableArray<Definition*>* detached_defs = nullptr);
+
  private:
   friend class FlowGraphCompiler;  // TODO(ajcbik): restructure
   friend class FlowGraphChecker;
diff --git a/runtime/vm/compiler/backend/flow_graph_checker.cc b/runtime/vm/compiler/backend/flow_graph_checker.cc
index e3f8fdd..6fad4a1 100644
--- a/runtime/vm/compiler/backend/flow_graph_checker.cc
+++ b/runtime/vm/compiler/backend/flow_graph_checker.cc
@@ -403,6 +403,13 @@
     ASSERT1(def->previous() != nullptr, def);
     // Skip checks below for common constants as checking them could be slow.
     if (IsCommonConstant(def)) return;
+  } else if (def->IsMaterializeObject()) {
+    // Materializations can be both linked into graph and detached.
+    if (def->next() != nullptr) {
+      ASSERT1(def->previous() != nullptr, def);
+    } else {
+      ASSERT1(def->previous() == nullptr, def);
+    }
   } else {
     // Others are fully linked into graph.
     ASSERT1(def->next() != nullptr, def);
@@ -453,6 +460,14 @@
     ASSERT1(instruction->IsGraphEntry() || instruction->next() != nullptr,
             instruction);
     ASSERT2(DefDominatesUse(def, instruction), def, instruction);
+  } else if (instruction->IsMaterializeObject()) {
+    // Materializations can be both linked into graph and detached.
+    if (instruction->next() != nullptr) {
+      ASSERT1(instruction->previous() != nullptr, instruction);
+      ASSERT2(DefDominatesUse(def, instruction), def, instruction);
+    } else {
+      ASSERT1(instruction->previous() == nullptr, instruction);
+    }
   } else {
     // Others are fully linked into graph.
     ASSERT1(IsControlFlow(instruction) || instruction->next() != nullptr,
diff --git a/runtime/vm/compiler/backend/il.cc b/runtime/vm/compiler/backend/il.cc
index 0dcade7..7182992 100644
--- a/runtime/vm/compiler/backend/il.cc
+++ b/runtime/vm/compiler/backend/il.cc
@@ -1057,6 +1057,11 @@
          (needs_number_check() == other_op->needs_number_check());
 }
 
+const RuntimeEntry& CaseInsensitiveCompareInstr::TargetFunction() const {
+  return handle_surrogates_ ? kCaseInsensitiveCompareUTF16RuntimeEntry
+                            : kCaseInsensitiveCompareUCS2RuntimeEntry;
+}
+
 bool MathMinMaxInstr::AttributesEqual(const Instruction& other) const {
   auto const other_op = other.AsMathMinMax();
   ASSERT(other_op != NULL);
@@ -3143,10 +3148,10 @@
     }
   }
 
-  if ((speculative_mode_ == kGuardInputs) && !ComputeCanDeoptimize()) {
+  if ((SpeculativeModeOfInput(0) == kGuardInputs) && !ComputeCanDeoptimize()) {
     // Remember if we ever learn out input doesn't require checking, as
     // the input Value might be later changed that would make us forget.
-    speculative_mode_ = kNotSpeculative;
+    set_speculative_mode(kNotSpeculative);
   }
 
   return this;
diff --git a/runtime/vm/compiler/backend/il.h b/runtime/vm/compiler/backend/il.h
index 878c309..e8023e6 100644
--- a/runtime/vm/compiler/backend/il.h
+++ b/runtime/vm/compiler/backend/il.h
@@ -11,11 +11,13 @@
 
 #include <memory>
 #include <tuple>
+#include <type_traits>
 #include <utility>
 
 #include "vm/allocation.h"
 #include "vm/code_descriptors.h"
 #include "vm/compiler/backend/compile_type.h"
+#include "vm/compiler/backend/il_serializer.h"
 #include "vm/compiler/backend/locations.h"
 #include "vm/compiler/backend/slot.h"
 #include "vm/compiler/compiler_pass.h"
@@ -588,6 +590,63 @@
   DECLARE_INSTRUCTION_NO_BACKEND(type)                                         \
   DECLARE_COMPARISON_METHODS
 
+template <typename T, bool is_enum>
+struct unwrap_enum {};
+
+template <typename T>
+struct unwrap_enum<T, true> {
+  using type = std::underlying_type_t<T>;
+};
+
+template <typename T>
+struct unwrap_enum<T, false> {
+  using type = T;
+};
+
+template <typename T>
+using serializable_type_t =
+    typename unwrap_enum<std::remove_cv_t<T>, std::is_enum<T>::value>::type;
+
+#define WRITE_INSTRUCTION_FIELD(type, name)                                    \
+  s->Write<serializable_type_t<type>>(                                         \
+      static_cast<serializable_type_t<type>>(name));
+#define READ_INSTRUCTION_FIELD(type, name)                                     \
+  , name(static_cast<std::remove_cv_t<type>>(                                  \
+        d->Read<serializable_type_t<type>>()))
+#define DECLARE_INSTRUCTION_FIELD(type, name) type name;
+
+// Every instruction class should declare its serialization via
+// DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS, DECLARE_EMPTY_SERIALIZATION
+// or DECLARE_CUSTOM_SERIALIZATION.
+// If instruction class has fields which reference other instructions,
+// then it should also use DECLARE_EXTRA_SERIALIZATION and serialize
+// those references in WriteExtra/ReadExtra methods.
+#define DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(Instr, BaseClass, FieldList)   \
+ public:                                                                       \
+  virtual void WriteTo(FlowGraphSerializer* s) {                               \
+    BaseClass::WriteTo(s);                                                     \
+    FieldList(WRITE_INSTRUCTION_FIELD)                                         \
+  }                                                                            \
+  explicit Instr(FlowGraphDeserializer* d)                                     \
+      : BaseClass(d) FieldList(READ_INSTRUCTION_FIELD) {}                      \
+                                                                               \
+ private:                                                                      \
+  FieldList(DECLARE_INSTRUCTION_FIELD)
+
+#define DECLARE_CUSTOM_SERIALIZATION(Instr)                                    \
+ public:                                                                       \
+  virtual void WriteTo(FlowGraphSerializer* s);                                \
+  explicit Instr(FlowGraphDeserializer* d);
+
+#define DECLARE_EMPTY_SERIALIZATION(Instr, BaseClass)                          \
+ public:                                                                       \
+  explicit Instr(FlowGraphDeserializer* d) : BaseClass(d) {}
+
+#define DECLARE_EXTRA_SERIALIZATION                                            \
+ public:                                                                       \
+  virtual void WriteExtra(FlowGraphSerializer* s);                             \
+  virtual void ReadExtra(FlowGraphDeserializer* d);
+
 #if defined(INCLUDE_IL_PRINTER)
 #define PRINT_TO_SUPPORT virtual void PrintTo(BaseTextBuffer* f) const;
 #define PRINT_OPERANDS_TO_SUPPORT                                              \
@@ -716,6 +775,9 @@
     return true;
   }
 
+  void Write(FlowGraphSerializer* s) const;
+  explicit CallTargets(FlowGraphDeserializer* d);
+
  private:
   void CreateHelper(Zone* zone, const ICData& ic_data);
   void MergeIntoRanges();
@@ -1270,6 +1332,9 @@
     return Location::kRegister;
   }
 
+  DECLARE_CUSTOM_SERIALIZATION(Instruction)
+  DECLARE_EXTRA_SERIALIZATION
+
  protected:
   // GetDeoptId and/or CopyDeoptIdFrom.
   friend class CallSiteInliner;
@@ -1288,6 +1353,12 @@
     deopt_id_ = instr.deopt_id_;
   }
 
+  // Write/read locs and environment, but not inputs.
+  // Used when one instruction embeds another and reuses their inputs
+  // (e.g. Branch/IfThenElse/CheckCondition wrap Comparison).
+  void WriteExtraWithoutInputs(FlowGraphSerializer* s);
+  void ReadExtraWithoutInputs(FlowGraphDeserializer* d);
+
  private:
   friend class BranchInstr;          // For RawSetInputAt.
   friend class IfThenElseInstr;      // For RawSetInputAt.
@@ -1340,6 +1411,8 @@
 
   virtual bool AllowsCSE() const { return true; }
   virtual bool HasUnknownSideEffects() const { return false; }
+
+  DECLARE_EMPTY_SERIALIZATION(PureInstruction, Instruction)
 };
 
 // Types to be used as ThrowsTrait for TemplateInstruction/TemplateDefinition.
@@ -1384,6 +1457,8 @@
 
   virtual bool MayThrow() const { return ThrowsTrait::kCanThrow; }
 
+  DECLARE_EMPTY_SERIALIZATION(TemplateInstruction, BaseClass)
+
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
@@ -1484,6 +1559,8 @@
   }
 
   PRINT_TO_SUPPORT
+  DECLARE_EMPTY_SERIALIZATION(ParallelMoveInstr, TemplateInstruction)
+  DECLARE_EXTRA_SERIALIZATION
 
  private:
   GrowableArray<MoveOperands*> moves_;  // Elements cannot be null.
@@ -1624,6 +1701,9 @@
 
   DECLARE_ABSTRACT_INSTRUCTION(BlockEntry)
 
+  DECLARE_CUSTOM_SERIALIZATION(BlockEntryInstr)
+  DECLARE_EXTRA_SERIALIZATION
+
  protected:
   BlockEntryInstr(intptr_t block_id,
                   intptr_t try_index,
@@ -1774,6 +1854,9 @@
     return this;
   }
 
+  DECLARE_CUSTOM_SERIALIZATION(BlockEntryWithInitialDefs)
+  DECLARE_EXTRA_SERIALIZATION
+
  protected:
   void PrintInitialDefinitionsTo(BaseTextBuffer* f) const;
 
@@ -1856,6 +1939,8 @@
   }
 
   PRINT_TO_SUPPORT
+  DECLARE_CUSTOM_SERIALIZATION(GraphEntryInstr)
+  DECLARE_EXTRA_SERIALIZATION
 
  private:
   GraphEntryInstr(const ParsedFunction& parsed_function,
@@ -1888,8 +1973,9 @@
                  intptr_t deopt_id,
                  intptr_t stack_depth = 0)
       : BlockEntryInstr(block_id, try_index, deopt_id, stack_depth),
-        predecessors_(2),  // Two is the assumed to be the common case.
-        phis_(NULL) {}
+        phis_(nullptr),
+        predecessors_(2)  // Two is the assumed to be the common case.
+  {}
 
   DECLARE_INSTRUCTION(JoinEntry)
 
@@ -1913,6 +1999,14 @@
 
   PRINT_TO_SUPPORT
 
+#define FIELD_LIST(F) F(ZoneGrowableArray<PhiInstr*>*, phis_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(JoinEntryInstr,
+                                          BlockEntryInstr,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+  DECLARE_EXTRA_SERIALIZATION
+
  private:
   // Classes that have access to predecessors_ when inlining.
   friend class BlockEntryInstr;
@@ -1928,7 +2022,6 @@
   virtual void AddPredecessor(BlockEntryInstr* predecessor);
 
   GrowableArray<BlockEntryInstr*> predecessors_;
-  ZoneGrowableArray<PhiInstr*>* phis_;
 
   DISALLOW_COPY_AND_ASSIGN(JoinEntryInstr);
 };
@@ -1961,7 +2054,6 @@
                    intptr_t deopt_id,
                    intptr_t stack_depth = 0)
       : BlockEntryInstr(block_id, try_index, deopt_id, stack_depth),
-        predecessor_(NULL),
         edge_weight_(0.0) {}
 
   DECLARE_INSTRUCTION(TargetEntry)
@@ -1980,6 +2072,12 @@
 
   PRINT_TO_SUPPORT
 
+#define FIELD_LIST(F) F(double, edge_weight_)
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(TargetEntryInstr,
+                                          BlockEntryInstr,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   friend class BlockEntryInstr;  // Access to predecessor_ when inlining.
 
@@ -1989,8 +2087,8 @@
     predecessor_ = predecessor;
   }
 
-  BlockEntryInstr* predecessor_;
-  double edge_weight_;
+  // Not serialized, set in DiscoverBlocks.
+  BlockEntryInstr* predecessor_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(TargetEntryInstr);
 };
@@ -2029,6 +2127,7 @@
   GraphEntryInstr* graph_entry() const { return graph_entry_; }
 
   PRINT_TO_SUPPORT
+  DECLARE_CUSTOM_SERIALIZATION(FunctionEntryInstr)
 
  private:
   virtual void ClearPredecessors() { graph_entry_ = nullptr; }
@@ -2062,13 +2161,19 @@
 
   PRINT_TO_SUPPORT
 
+#define FIELD_LIST(F)                                                          \
+  F(const intptr_t, callback_id_)                                              \
+  F(const compiler::ffi::CallbackMarshaller&, marshaller_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(NativeEntryInstr,
+                                          FunctionEntryInstr,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   void SaveArguments(FlowGraphCompiler* compiler) const;
   void SaveArgument(FlowGraphCompiler* compiler,
                     const compiler::ffi::NativeLocation& loc) const;
-
-  const intptr_t callback_id_;
-  const compiler::ffi::CallbackMarshaller& marshaller_;
 };
 
 // Represents an OSR entrypoint to a function.
@@ -2097,6 +2202,7 @@
   GraphEntryInstr* graph_entry() const { return graph_entry_; }
 
   PRINT_TO_SUPPORT
+  DECLARE_CUSTOM_SERIALIZATION(OsrEntryInstr)
 
  private:
   virtual void ClearPredecessors() { graph_entry_ = nullptr; }
@@ -2125,8 +2231,12 @@
 
   PRINT_TO_SUPPORT
 
- private:
-  const intptr_t indirect_id_;
+#define FIELD_LIST(F) F(const intptr_t, indirect_id_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(IndirectEntryInstr,
+                                          JoinEntryInstr,
+                                          FIELD_LIST)
+#undef FIELD_LIST
 };
 
 class CatchBlockEntryInstr : public BlockEntryWithInitialDefs {
@@ -2187,6 +2297,7 @@
   intptr_t catch_try_index() const { return catch_try_index_; }
 
   PRINT_TO_SUPPORT
+  DECLARE_CUSTOM_SERIALIZATION(CatchBlockEntryInstr)
 
  private:
   friend class BlockEntryInstr;  // Access to predecessor_ when inlining.
@@ -2201,7 +2312,6 @@
   BlockEntryInstr* predecessor_;
   const Array& catch_handler_types_;
   const intptr_t catch_try_index_;
-  GrowableArray<Definition*> initial_definitions_;
   const LocalVariable* exception_var_;
   const LocalVariable* stacktrace_var_;
   const LocalVariable* raw_exception_var_;
@@ -2266,6 +2376,9 @@
     return *this;
   }
 
+  void Write(FlowGraphSerializer* s) const;
+  explicit AliasIdentity(FlowGraphDeserializer* d);
+
  private:
   explicit AliasIdentity(intptr_t value) : value_(value) {}
 
@@ -2460,6 +2573,8 @@
   virtual Definition* AsDefinition() { return this; }
   virtual const Definition* AsDefinition() const { return this; }
 
+  DECLARE_CUSTOM_SERIALIZATION(Definition)
+
  protected:
   friend class RangeAnalysis;
   friend class Value;
@@ -2510,6 +2625,8 @@
 
   virtual bool AllowsCSE() const { return true; }
   virtual bool HasUnknownSideEffects() const { return false; }
+
+  DECLARE_EMPTY_SERIALIZATION(PureDefinition, Definition)
 };
 
 template <intptr_t N,
@@ -2530,6 +2647,7 @@
 
   virtual bool MayThrow() const { return ThrowsTrait::kCanThrow; }
 
+  DECLARE_EMPTY_SERIALIZATION(TemplateDefinition, BaseClass)
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
@@ -2572,6 +2690,8 @@
   intptr_t InputCount() const { return inputs_.length(); }
   Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
+  DECLARE_CUSTOM_SERIALIZATION(VariadicDefinition)
+
  protected:
   InputsArray inputs_;
 
@@ -2648,6 +2768,7 @@
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   PRINT_TO_SUPPORT
+  DECLARE_CUSTOM_SERIALIZATION(PhiInstr)
 
   enum ReceiverType { kUnknownReceiver = -1, kNotReceiver = 0, kReceiver = 1 };
 
@@ -2722,17 +2843,23 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const intptr_t index_;
+#define FIELD_LIST(F)                                                          \
+  F(const intptr_t, index_)                                                    \
+  /* The offset (in words) of the last slot of the parameter, relative */      \
+  /* to the first parameter. */                                                \
+  /* It is used in the FlowGraphAllocator when it sets the assigned */         \
+  /* location and spill slot for the parameter definition. */                  \
+  F(const intptr_t, param_offset_)                                             \
+  F(const Register, base_reg_)                                                 \
+  F(const Representation, representation_)
 
-  // The offset (in words) of the last slot of the parameter, relative
-  // to the first parameter.
-  // It is used in the FlowGraphAllocator when it sets the assigned location
-  // and spill slot for the parameter definition.
-  const intptr_t param_offset_;
-  const Register base_reg_;
-  const Representation representation_;
-  BlockEntryInstr* block_;
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(ParameterInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
+  BlockEntryInstr* block_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(ParameterInstr);
 };
@@ -2765,10 +2892,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const compiler::ffi::CallbackMarshaller& marshaller_;
-  const intptr_t def_index_;
+#define FIELD_LIST(F)                                                          \
+  F(const compiler::ffi::CallbackMarshaller&, marshaller_)                     \
+  F(const intptr_t, def_index_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(NativeParameterInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(NativeParameterInstr);
 };
 
@@ -2815,9 +2948,14 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const intptr_t offset_;
+#define FIELD_LIST(F) F(const intptr_t, offset_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(StoreIndexedUnsafeInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(StoreIndexedUnsafeInstr);
 };
 
@@ -2865,10 +3003,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const intptr_t offset_;
-  const Representation representation_;
+#define FIELD_LIST(F)                                                          \
+  F(const intptr_t, offset_)                                                   \
+  F(const Representation, representation_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(LoadIndexedUnsafeInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(LoadIndexedUnsafeInstr);
 };
 
@@ -2921,6 +3065,16 @@
   Value* dest_start() const { return inputs_[kDestStartPos]; }
   Value* length() const { return inputs_[kLengthPos]; }
 
+#define FIELD_LIST(F)                                                          \
+  F(classid_t, src_cid_)                                                       \
+  F(classid_t, dest_cid_)                                                      \
+  F(intptr_t, element_size_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(MemoryCopyInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   // Set array_reg to point to the index indicated by start (contained in
   // start_reg) of the typed data or string in array (contained in array_reg).
@@ -2945,10 +3099,6 @@
     }
   }
 
-  classid_t src_cid_;
-  classid_t dest_cid_;
-  intptr_t element_size_;
-
   DISALLOW_COPY_AND_ASSIGN(MemoryCopyInstr);
 };
 
@@ -2983,9 +3133,14 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const Code& code_;
+#define FIELD_LIST(F) F(const Code&, code_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(TailCallInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(TailCallInstr);
 };
 
@@ -3019,9 +3174,14 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const Representation representation_;
+#define FIELD_LIST(F) F(const Representation, representation_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(PushArgumentInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
 };
 
@@ -3089,11 +3249,17 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const TokenPosition token_pos_;
-  const intptr_t yield_index_;
-  const Representation representation_;
+#define FIELD_LIST(F)                                                          \
+  F(const TokenPosition, token_pos_)                                           \
+  F(const intptr_t, yield_index_)                                              \
+  F(const Representation, representation_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(ReturnInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   const Code& GetReturnStub(FlowGraphCompiler* compiler) const;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
@@ -3123,9 +3289,14 @@
     return false;
   }
 
- private:
-  const compiler::ffi::CallbackMarshaller& marshaller_;
+#define FIELD_LIST(F) F(const compiler::ffi::CallbackMarshaller&, marshaller_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(NativeReturnInstr,
+                                          ReturnInstr,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   void EmitReturnMoves(FlowGraphCompiler* compiler);
 
   DISALLOW_COPY_AND_ASSIGN(NativeReturnInstr);
@@ -3151,9 +3322,14 @@
 
   virtual bool HasUnknownSideEffects() const { return false; }
 
- private:
-  const TokenPosition token_pos_;
+#define FIELD_LIST(F) F(const TokenPosition, token_pos_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(ThrowInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
@@ -3186,10 +3362,16 @@
 
   virtual bool HasUnknownSideEffects() const { return false; }
 
- private:
-  const TokenPosition token_pos_;
-  const intptr_t catch_try_index_;
+#define FIELD_LIST(F)                                                          \
+  F(const TokenPosition, token_pos_)                                           \
+  F(const intptr_t, catch_try_index_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(ReThrowInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
 
@@ -3207,9 +3389,14 @@
 
   virtual bool HasUnknownSideEffects() const { return false; }
 
- private:
-  const char* message_;
+#define FIELD_LIST(F) F(const char*, message_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(StopInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(StopInstr);
 };
 
@@ -3217,10 +3404,9 @@
  public:
   explicit GotoInstr(JoinEntryInstr* entry, intptr_t deopt_id)
       : TemplateInstruction(deopt_id),
-        block_(NULL),
-        successor_(entry),
         edge_weight_(0.0),
-        parallel_move_(NULL) {}
+        parallel_move_(nullptr),
+        successor_(entry) {}
 
   DECLARE_INSTRUCTION(Goto)
 
@@ -3270,14 +3456,23 @@
 
   PRINT_TO_SUPPORT
 
- private:
-  BlockEntryInstr* block_;
-  JoinEntryInstr* successor_;
-  double edge_weight_;
+#define FIELD_LIST(F)                                                          \
+  F(double, edge_weight_)                                                      \
+  /* Parallel move that will be used by linear scan register allocator to */   \
+  /* connect live ranges at the end of the block and resolve phis. */          \
+  F(ParallelMoveInstr*, parallel_move_)
 
-  // Parallel move that will be used by linear scan register allocator to
-  // connect live ranges at the end of the block and resolve phis.
-  ParallelMoveInstr* parallel_move_;
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(GotoInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+  DECLARE_EXTRA_SERIALIZATION
+
+ private:
+  BlockEntryInstr* block_ = nullptr;
+  JoinEntryInstr* successor_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(GotoInstr);
 };
 
 // IndirectGotoInstr represents a dynamically computed jump. Only
@@ -3339,9 +3534,14 @@
 
   PRINT_TO_SUPPORT
 
+  DECLARE_CUSTOM_SERIALIZATION(IndirectGotoInstr)
+  DECLARE_EXTRA_SERIALIZATION
+
  private:
   GrowableArray<TargetEntryInstr*> successors_;
   const TypedData& offsets_;
+
+  DISALLOW_COPY_AND_ASSIGN(IndirectGotoInstr);
 };
 
 class ComparisonInstr : public Definition {
@@ -3393,6 +3593,17 @@
 
   DECLARE_ABSTRACT_INSTRUCTION(Comparison)
 
+#define FIELD_LIST(F)                                                          \
+  F(const TokenPosition, token_pos_)                                           \
+  F(Token::Kind, kind_)                                                        \
+  /* Set by optimizer. */                                                      \
+  F(intptr_t, operation_cid_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(ComparisonInstr,
+                                          Definition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  protected:
   ComparisonInstr(const InstructionSource& source,
                   Token::Kind kind,
@@ -3403,10 +3614,6 @@
         operation_cid_(kIllegalCid) {}
 
  private:
-  const TokenPosition token_pos_;
-  Token::Kind kind_;
-  intptr_t operation_cid_;  // Set by optimizer.
-
   DISALLOW_COPY_AND_ASSIGN(ComparisonInstr);
 };
 
@@ -3415,6 +3622,7 @@
   virtual bool AllowsCSE() const { return true; }
   virtual bool HasUnknownSideEffects() const { return false; }
 
+  DECLARE_EMPTY_SERIALIZATION(PureComparison, ComparisonInstr)
  protected:
   PureComparison(const InstructionSource& source,
                  Token::Kind kind,
@@ -3428,17 +3636,20 @@
 class TemplateComparison
     : public CSETrait<ComparisonInstr, PureComparison>::Base {
  public:
+  using BaseClass = typename CSETrait<ComparisonInstr, PureComparison>::Base;
+
   TemplateComparison(const InstructionSource& source,
                      Token::Kind kind,
                      intptr_t deopt_id = DeoptId::kNone)
-      : CSETrait<ComparisonInstr, PureComparison>::Base(source, kind, deopt_id),
-        inputs_() {}
+      : BaseClass(source, kind, deopt_id), inputs_() {}
 
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   virtual bool MayThrow() const { return ThrowsTrait::kCanThrow; }
 
+  DECLARE_EMPTY_SERIALIZATION(TemplateComparison, BaseClass)
+
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
@@ -3449,7 +3660,7 @@
 class BranchInstr : public Instruction {
  public:
   explicit BranchInstr(ComparisonInstr* comparison, intptr_t deopt_id)
-      : Instruction(deopt_id), comparison_(comparison), constant_target_(NULL) {
+      : Instruction(deopt_id), comparison_(comparison) {
     ASSERT(comparison->env() == NULL);
     for (intptr_t i = comparison->InputCount() - 1; i >= 0; --i) {
       comparison->InputAt(i)->set_instruction(this);
@@ -3529,15 +3740,20 @@
 
   PRINT_TO_SUPPORT
 
+#define FIELD_LIST(F) F(ComparisonInstr*, comparison_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(BranchInstr, Instruction, FIELD_LIST)
+#undef FIELD_LIST
+  DECLARE_EXTRA_SERIALIZATION
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     comparison()->RawSetInputAt(i, value);
   }
 
-  TargetEntryInstr* true_successor_;
-  TargetEntryInstr* false_successor_;
-  ComparisonInstr* comparison_;
-  TargetEntryInstr* constant_target_;
+  TargetEntryInstr* true_successor_ = nullptr;
+  TargetEntryInstr* false_successor_ = nullptr;
+  TargetEntryInstr* constant_target_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
@@ -3553,9 +3769,14 @@
 
   DECLARE_INSTRUCTION(Deoptimize)
 
- private:
-  const ICData::DeoptReasonId deopt_reason_;
+#define FIELD_LIST(F) F(const ICData::DeoptReasonId, deopt_reason_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(DeoptimizeInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(DeoptimizeInstr);
 };
 
@@ -3584,8 +3805,14 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F) F(CompileType*, constrained_type_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(RedefinitionInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
-  CompileType* constrained_type_;
   DISALLOW_COPY_AND_ASSIGN(RedefinitionInstr);
 };
 
@@ -3609,14 +3836,15 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+  DECLARE_EMPTY_SERIALIZATION(ReachabilityFenceInstr, TemplateInstruction)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ReachabilityFenceInstr);
 };
 
 class ConstraintInstr : public TemplateDefinition<1, NoThrow> {
  public:
-  ConstraintInstr(Value* value, Range* constraint)
-      : constraint_(constraint), target_(NULL) {
+  ConstraintInstr(Value* value, Range* constraint) : constraint_(constraint) {
     SetInputAt(0, value);
   }
 
@@ -3646,9 +3874,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F) F(Range*, constraint_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(ConstraintInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+  DECLARE_EXTRA_SERIALIZATION
+
  private:
-  Range* constraint_;
-  TargetEntryInstr* target_;
+  TargetEntryInstr* target_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(ConstraintInstr);
 };
@@ -3700,10 +3935,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const Object& value_;
-  const TokenPosition token_pos_;
+#define FIELD_LIST(F)                                                          \
+  F(const Object&, value_)                                                     \
+  F(const TokenPosition, token_pos_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(ConstantInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(ConstantInstr);
 };
 
@@ -3721,6 +3962,7 @@
   uword constant_address() const { return constant_address_; }
 
   DECLARE_INSTRUCTION(UnboxedConstant)
+  DECLARE_CUSTOM_SERIALIZATION(UnboxedConstantInstr)
 
  private:
   const Representation representation_;
@@ -3785,9 +4027,14 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const TokenPosition token_pos_;
+#define FIELD_LIST(F) F(const TokenPosition, token_pos_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(AssertSubtypeInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(AssertSubtypeInstr);
 };
 
@@ -3881,11 +4128,17 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const TokenPosition token_pos_;
-  const String& dst_name_;
-  const Kind kind_;
+#define FIELD_LIST(F)                                                          \
+  F(const TokenPosition, token_pos_)                                           \
+  F(const String&, dst_name_)                                                  \
+  F(const Kind, kind_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(AssertAssignableInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableInstr);
 };
 
@@ -3920,9 +4173,14 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const TokenPosition token_pos_;
+#define FIELD_LIST(F) F(const TokenPosition, token_pos_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(AssertBooleanInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
 };
 
@@ -3974,9 +4232,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F) F(const SpecialParameterKind, kind_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(SpecialParameterInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+  DECLARE_EXTRA_SERIALIZATION
+
  private:
-  const SpecialParameterKind kind_;
-  BlockEntryInstr* block_;
+  BlockEntryInstr* block_ = nullptr;
   DISALLOW_COPY_AND_ASSIGN(SpecialParameterInstr);
 };
 
@@ -4083,11 +4348,19 @@
         ArgumentsSizeWithoutTypeArgs(), argument_names());
   }
 
+#define FIELD_LIST(F)                                                          \
+  F(const intptr_t, type_args_len_)                                            \
+  F(const Array&, argument_names_)                                             \
+  F(const TokenPosition, token_pos_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(TemplateDartCall,
+                                          VariadicDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+  DECLARE_EXTRA_SERIALIZATION
+
  private:
-  intptr_t type_args_len_;
-  const Array& argument_names_;
   PushArgumentsArray* push_arguments_ = nullptr;
-  TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(TemplateDartCall);
 };
@@ -4113,6 +4386,7 @@
   virtual bool HasUnknownSideEffects() const { return true; }
 
   PRINT_OPERANDS_TO_SUPPORT
+  DECLARE_EMPTY_SERIALIZATION(ClosureCallInstr, TemplateDartCall)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ClosureCallInstr);
@@ -4143,7 +4417,10 @@
         interface_target_(interface_target),
         tearoff_interface_target_(tearoff_interface_target),
         result_type_(nullptr),
-        has_unique_selector_(false) {
+        has_unique_selector_(false),
+        entry_kind_(Code::EntryKind::kNormal),
+        receiver_is_not_smi_(false),
+        is_call_on_this_(false) {
     ASSERT(function_name.IsNotTemporaryScopedHandle());
     ASSERT(interface_target.IsNotTemporaryScopedHandle());
     ASSERT(tearoff_interface_target.IsNotTemporaryScopedHandle());
@@ -4238,23 +4515,31 @@
 
   virtual Representation representation() const;
 
+#define FIELD_LIST(F)                                                          \
+  F(const ICData*, ic_data_)                                                   \
+  F(const String&, function_name_)                                             \
+  /* Binary op, unary op, kGET or kILLEGAL. */                                 \
+  F(const Token::Kind, token_kind_)                                            \
+  F(const Function&, interface_target_)                                        \
+  F(const Function&, tearoff_interface_target_)                                \
+  /* Inferred result type. */                                                  \
+  F(CompileType*, result_type_)                                                \
+  F(bool, has_unique_selector_)                                                \
+  F(Code::EntryKind, entry_kind_)                                              \
+  F(bool, receiver_is_not_smi_)                                                \
+  F(bool, is_call_on_this_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(InstanceCallBaseInstr,
+                                          TemplateDartCall,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  protected:
   friend class CallSpecializer;
   void set_ic_data(ICData* value) { ic_data_ = value; }
   void set_result_type(CompileType* result_type) { result_type_ = result_type; }
 
  private:
-  const ICData* ic_data_;
-  const String& function_name_;
-  const Token::Kind token_kind_;  // Binary op, unary op, kGET or kILLEGAL.
-  const Function& interface_target_;
-  const Function& tearoff_interface_target_;
-  CompileType* result_type_;  // Inferred result type.
-  bool has_unique_selector_;
-  Code::EntryKind entry_kind_ = Code::EntryKind::kNormal;
-  bool receiver_is_not_smi_ = false;
-  bool is_call_on_this_ = false;
-
   DISALLOW_COPY_AND_ASSIGN(InstanceCallBaseInstr);
 };
 
@@ -4283,7 +4568,8 @@
             deopt_id,
             interface_target,
             tearoff_interface_target),
-        checked_argument_count_(checked_argument_count) {}
+        checked_argument_count_(checked_argument_count),
+        receivers_static_type_(nullptr) {}
 
   InstanceCallInstr(
       const InstructionSource& source,
@@ -4306,7 +4592,8 @@
                               deopt_id,
                               interface_target,
                               tearoff_interface_target),
-        checked_argument_count_(checked_argument_count) {}
+        checked_argument_count_(checked_argument_count),
+        receivers_static_type_(nullptr) {}
 
   DECLARE_INSTRUCTION(InstanceCall)
 
@@ -4335,11 +4622,18 @@
   const CallTargets& Targets();
   void SetTargets(const CallTargets* targets) { targets_ = targets; }
 
+#define FIELD_LIST(F)                                                          \
+  F(const intptr_t, checked_argument_count_)                                   \
+  F(const AbstractType*, receivers_static_type_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(InstanceCallInstr,
+                                          InstanceCallBaseInstr,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   const CallTargets* targets_ = nullptr;
   const class BinaryFeedback* binary_ = nullptr;
-  const intptr_t checked_argument_count_;
-  const AbstractType* receivers_static_type_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceCallInstr);
 };
@@ -4402,6 +4696,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F)                                                          \
+  F(const CallTargets&, targets_)                                              \
+  F(const bool, complete_)                                                     \
+  F(intptr_t, total_call_count_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(PolymorphicInstanceCallInstr,
+                                          InstanceCallBaseInstr,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   PolymorphicInstanceCallInstr(const InstructionSource& source,
                                const String& function_name,
@@ -4431,10 +4735,6 @@
     total_call_count_ = CallCount();
   }
 
-  const CallTargets& targets_;
-  const bool complete_;
-  intptr_t total_call_count_;
-
   friend class PolymorphicInliner;
 
   DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallInstr);
@@ -4510,10 +4810,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const Function& interface_target_;
-  const compiler::TableSelector* selector_;
+#define FIELD_LIST(F)                                                          \
+  F(const Function&, interface_target_)                                        \
+  F(const compiler::TableSelector*, selector_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(DispatchTableCallInstr,
+                                          TemplateDartCall,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(DispatchTableCallInstr);
 };
 
@@ -4543,6 +4849,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT;
 
+#define FIELD_LIST(F)                                                          \
+  /* True if the comparison must check for double or Mint and */               \
+  /* use value comparison instead. */                                          \
+  F(bool, needs_number_check_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(StrictCompareInstr,
+                                          TemplateComparison,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   Condition EmitComparisonCodeRegConstant(FlowGraphCompiler* compiler,
                                           BranchLabels labels,
@@ -4554,10 +4870,6 @@
                        const Object& obj,
                        Condition* condition_out);
 
-  // True if the comparison must check for double or Mint and
-  // use value comparison instead.
-  bool needs_number_check_;
-
   DISALLOW_COPY_AND_ASSIGN(StrictCompareInstr);
 };
 
@@ -4587,6 +4899,8 @@
     return kTagged;
   }
 
+  DECLARE_EMPTY_SERIALIZATION(TestSmiInstr, TemplateComparison)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(TestSmiInstr);
 };
@@ -4632,9 +4946,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F)                                                          \
+  F(const ZoneGrowableArray<intptr_t>&, cid_results_)                          \
+  F(bool, licm_hoisted_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(TestCidsInstr,
+                                          TemplateComparison,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
-  const ZoneGrowableArray<intptr_t>& cid_results_;
-  bool licm_hoisted_;
   DISALLOW_COPY_AND_ASSIGN(TestCidsInstr);
 };
 
@@ -4690,9 +5011,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F)                                                          \
+  F(bool, null_aware_)                                                         \
+  F(const SpeculativeMode, speculative_mode_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(EqualityCompareInstr,
+                                          TemplateComparison,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
-  bool null_aware_;
-  const SpeculativeMode speculative_mode_;
   DISALLOW_COPY_AND_ASSIGN(EqualityCompareInstr);
 };
 
@@ -4739,8 +5067,14 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F) F(const SpeculativeMode, speculative_mode_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(RelationalOpInstr,
+                                          TemplateComparison,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
-  const SpeculativeMode speculative_mode_;
   DISALLOW_COPY_AND_ASSIGN(RelationalOpInstr);
 };
 
@@ -4815,15 +5149,22 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F)                                                          \
+  F(ComparisonInstr*, comparison_)                                             \
+  F(const intptr_t, if_true_)                                                  \
+  F(const intptr_t, if_false_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(IfThenElseInstr,
+                                          Definition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+  DECLARE_EXTRA_SERIALIZATION
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     comparison()->RawSetInputAt(i, value);
   }
 
-  ComparisonInstr* comparison_;
-  const intptr_t if_true_;
-  const intptr_t if_false_;
-
   DISALLOW_COPY_AND_ASSIGN(IfThenElseInstr);
 };
 
@@ -4848,6 +5189,7 @@
         rebind_rule_(rebind_rule),
         result_type_(NULL),
         is_known_list_constructor_(false),
+        entry_kind_(Code::EntryKind::kNormal),
         identity_(AliasIdentity::Unknown()) {
     ASSERT(function.IsZoneHandle());
     ASSERT(!function.IsNull());
@@ -4872,6 +5214,7 @@
         rebind_rule_(rebind_rule),
         result_type_(NULL),
         is_known_list_constructor_(false),
+        entry_kind_(Code::EntryKind::kNormal),
         identity_(AliasIdentity::Unknown()) {
     ASSERT(function.IsZoneHandle());
     ASSERT(!function.IsNull());
@@ -4990,21 +5333,26 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F)                                                          \
+  F(const ICData*, ic_data_)                                                   \
+  F(const intptr_t, call_count_)                                               \
+  F(const Function&, function_)                                                \
+  F(const ICData::RebindRule, rebind_rule_)                                    \
+  /* Known or inferred result type. */                                         \
+  F(CompileType*, result_type_)                                                \
+  /* 'True' for recognized list constructors. */                               \
+  F(bool, is_known_list_constructor_)                                          \
+  F(Code::EntryKind, entry_kind_)                                              \
+  F(AliasIdentity, identity_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(StaticCallInstr,
+                                          TemplateDartCall,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
-  const ICData* ic_data_;
   const CallTargets* targets_ = nullptr;
   const class BinaryFeedback* binary_ = nullptr;
-  const intptr_t call_count_;
-  const Function& function_;
-  const ICData::RebindRule rebind_rule_;
-  CompileType* result_type_;  // Known or inferred result type.
-
-  // 'True' for recognized list constructors.
-  bool is_known_list_constructor_;
-
-  Code::EntryKind entry_kind_ = Code::EntryKind::kNormal;
-
-  AliasIdentity identity_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticCallInstr);
 };
@@ -5036,11 +5384,17 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const LocalVariable& local_;
-  bool is_last_;
-  const TokenPosition token_pos_;
+#define FIELD_LIST(F)                                                          \
+  F(const LocalVariable&, local_)                                              \
+  F(bool, is_last_)                                                            \
+  F(const TokenPosition, token_pos_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(LoadLocalInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(LoadLocalInstr);
 };
 
@@ -5080,14 +5434,21 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F)                                                          \
+  F(const intptr_t, num_temps_)                                                \
+  F(const bool, has_input_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(DropTempsInstr,
+                                          Definition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     ASSERT(has_input_);
     value_ = value;
   }
 
-  const intptr_t num_temps_;
-  const bool has_input_;
   Value* value_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(DropTempsInstr);
@@ -5129,9 +5490,15 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  ConstantInstr* null_;
+#define FIELD_LIST(F) F(ConstantInstr*, null_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(MakeTempInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+  DECLARE_EXTRA_SERIALIZATION
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(MakeTempInstr);
 };
 
@@ -5171,12 +5538,18 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const LocalVariable& local_;
-  bool is_dead_;
-  bool is_last_;
-  const TokenPosition token_pos_;
+#define FIELD_LIST(F)                                                          \
+  F(const LocalVariable&, local_)                                              \
+  F(bool, is_dead_)                                                            \
+  F(bool, is_last_)                                                            \
+  F(const TokenPosition, token_pos_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(StoreLocalInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(StoreLocalInstr);
 };
 
@@ -5194,11 +5567,8 @@
                          source),
         native_name_(name),
         function_(function),
-        native_c_function_(NULL),
-        is_bootstrap_native_(false),
-        is_auto_scope_(true),
-        link_lazily_(link_lazily),
-        token_pos_(source.token_pos) {
+        token_pos_(source.token_pos),
+        link_lazily_(link_lazily) {
     ASSERT(name.IsZoneHandle());
     ASSERT(function.IsZoneHandle());
   }
@@ -5224,6 +5594,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F)                                                          \
+  F(const String&, native_name_)                                               \
+  F(const Function&, function_)                                                \
+  F(const TokenPosition, token_pos_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(NativeCallInstr,
+                                          TemplateDartCall,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   void set_native_c_function(NativeFunction value) {
     native_c_function_ = value;
@@ -5232,13 +5612,12 @@
   void set_is_bootstrap_native(bool value) { is_bootstrap_native_ = value; }
   void set_is_auto_scope(bool value) { is_auto_scope_ = value; }
 
-  const String& native_name_;
-  const Function& function_;
-  NativeFunction native_c_function_;
-  bool is_bootstrap_native_;
-  bool is_auto_scope_;
-  bool link_lazily_;
-  const TokenPosition token_pos_;
+  // These fields are not serialized.
+  // IL serialization only supports lazy linking of native functions.
+  NativeFunction native_c_function_ = nullptr;
+  bool is_bootstrap_native_ = false;
+  bool is_auto_scope_ = true;
+  bool link_lazily_ = true;
 
   DISALLOW_COPY_AND_ASSIGN(NativeCallInstr);
 };
@@ -5303,6 +5682,15 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F)                                                          \
+  F(const compiler::ffi::CallMarshaller&, marshaller_)                         \
+  F(bool, is_leaf_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(FfiCallInstr,
+                                          VariadicDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   LocationSummary* MakeLocationSummaryInternal(Zone* zone,
                                                bool is_optimizing,
@@ -5320,9 +5708,6 @@
                        const Register temp0,
                        const Register temp1);
 
-  const compiler::ffi::CallMarshaller& marshaller_;
-  bool is_leaf_;
-
   DISALLOW_COPY_AND_ASSIGN(FfiCallInstr);
 };
 
@@ -5360,9 +5745,15 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const compiler::ffi::NativeCallingConvention& native_calling_convention_;
+#define FIELD_LIST(F)                                                          \
+  F(const compiler::ffi::NativeCallingConvention&, native_calling_convention_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(CCallInstr,
+                                          VariadicDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(CCallInstr);
 };
 
@@ -5390,9 +5781,14 @@
   virtual bool ComputeCanDeoptimize() const { return false; }
   virtual bool HasUnknownSideEffects() const { return false; }
 
- private:
-  const int32_t offset_;
+#define FIELD_LIST(F) F(const int32_t, offset_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(RawStoreFieldInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(RawStoreFieldInstr);
 };
 
@@ -5412,10 +5808,16 @@
   virtual bool HasUnknownSideEffects() const { return true; }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
- private:
-  const TokenPosition token_pos_;
-  const UntaggedPcDescriptors::Kind stub_kind_;
+#define FIELD_LIST(F)                                                          \
+  F(const TokenPosition, token_pos_)                                           \
+  F(const UntaggedPcDescriptors::Kind, stub_kind_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(DebugStepCheckInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(DebugStepCheckInstr);
 };
 
@@ -5566,6 +5968,19 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F)                                                          \
+  F(const Slot&, slot_)                                                        \
+  F(StoreBarrierType, emit_store_barrier_)                                     \
+  F(compiler::Assembler::MemoryOrder, memory_order_)                           \
+  F(const TokenPosition, token_pos_)                                           \
+  /* Marks initializing stores. E.g. in the constructor. */                    \
+  F(const bool, is_initialization_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(StoreFieldInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   friend class JitCallSpecializer;  // For ASSERT(initialization_).
 
@@ -5578,13 +5993,6 @@
                                        : compiler::Assembler::kValueIsNotSmi;
   }
 
-  const Slot& slot_;
-  StoreBarrierType emit_store_barrier_;
-  compiler::Assembler::MemoryOrder memory_order_;
-  const TokenPosition token_pos_;
-  // Marks initializing stores. E.g. in the constructor.
-  const bool is_initialization_;
-
   DISALLOW_COPY_AND_ASSIGN(StoreFieldInstr);
 };
 
@@ -5608,9 +6016,14 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const Field& field_;
+#define FIELD_LIST(F) F(const Field&, field_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(GuardFieldInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(GuardFieldInstr);
 };
 
@@ -5627,6 +6040,8 @@
 
   virtual bool AttributesEqual(const Instruction& other) const;
 
+  DECLARE_EMPTY_SERIALIZATION(GuardFieldClassInstr, GuardFieldInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(GuardFieldClassInstr);
 };
@@ -5644,6 +6059,8 @@
 
   virtual bool AttributesEqual(const Instruction& other) const;
 
+  DECLARE_EMPTY_SERIALIZATION(GuardFieldLengthInstr, GuardFieldInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(GuardFieldLengthInstr);
 };
@@ -5667,6 +6084,8 @@
 
   virtual bool AttributesEqual(const Instruction& other) const;
 
+  DECLARE_EMPTY_SERIALIZATION(GuardFieldTypeInstr, GuardFieldInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(GuardFieldTypeInstr);
 };
@@ -5725,11 +6144,15 @@
   virtual bool CanTriggerGC() const { return calls_initializer(); }
   virtual bool MayThrow() const { return calls_initializer(); }
 
- private:
-  const TokenPosition token_pos_;
-  const bool throw_exception_on_initialization_;
-  bool calls_initializer_;
+#define FIELD_LIST(F)                                                          \
+  F(const TokenPosition, token_pos_)                                           \
+  F(const bool, throw_exception_on_initialization_)                            \
+  F(bool, calls_initializer_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(TemplateLoadField, Base, FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(TemplateLoadField);
 };
 
@@ -5764,9 +6187,14 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const Field& field_;
+#define FIELD_LIST(F) F(const Field&, field_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(LoadStaticFieldInstr,
+                                          TemplateLoadField,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldInstr);
 };
 
@@ -5801,6 +6229,15 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F)                                                          \
+  F(const Field&, field_)                                                      \
+  F(const TokenPosition, token_pos_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(StoreStaticFieldInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   compiler::Assembler::CanBeSmi CanValueBeSmi() const {
     ASSERT(value()->Type()->ToNullableCid() != kSmiCid);
@@ -5808,9 +6245,6 @@
                                        : compiler::Assembler::kValueIsNotSmi;
   }
 
-  const Field& field_;
-  const TokenPosition token_pos_;
-
   DISALLOW_COPY_AND_ASSIGN(StoreStaticFieldInstr);
 };
 
@@ -5881,14 +6315,21 @@
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
- private:
-  const bool index_unboxed_;
-  const intptr_t index_scale_;
-  const intptr_t class_id_;
-  const AlignmentType alignment_;
-  const TokenPosition token_pos_;
-  CompileType* result_type_;  // derived from call
+#define FIELD_LIST(F)                                                          \
+  F(const bool, index_unboxed_)                                                \
+  F(const intptr_t, index_scale_)                                              \
+  F(const intptr_t, class_id_)                                                 \
+  F(const AlignmentType, alignment_)                                           \
+  F(const TokenPosition, token_pos_)                                           \
+  /* derived from call */                                                      \
+  F(CompileType*, result_type_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(LoadIndexedInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(LoadIndexedInstr);
 };
 
@@ -5962,12 +6403,18 @@
     return !can_pack_into_smi() && (representation() == kTagged);
   }
 
- private:
-  const intptr_t class_id_;
-  const TokenPosition token_pos_;
-  const intptr_t element_count_;
-  Representation representation_;
+#define FIELD_LIST(F)                                                          \
+  F(const intptr_t, class_id_)                                                 \
+  F(const TokenPosition, token_pos_)                                           \
+  F(const intptr_t, element_count_)                                            \
+  F(Representation, representation_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(LoadCodeUnitsInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(LoadCodeUnitsInstr);
 };
 
@@ -5987,6 +6434,9 @@
 
   virtual bool AttributesEqual(const Instruction& other) const { return true; }
 
+  DECLARE_EMPTY_SERIALIZATION(OneByteStringFromCharCodeInstr,
+                              TemplateDefinition)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(OneByteStringFromCharCodeInstr);
 };
@@ -6009,9 +6459,14 @@
     return other.AsStringToCharCode()->cid_ == cid_;
   }
 
- private:
-  const intptr_t cid_;
+#define FIELD_LIST(F) F(const intptr_t, cid_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(StringToCharCodeInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(StringToCharCodeInstr);
 };
 
@@ -6083,9 +6538,14 @@
 
   PRINT_TO_SUPPORT
 
- private:
-  const Slot& scan_flags_field_;
+#define FIELD_LIST(F) F(const Slot&, scan_flags_field_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(Utf8ScanInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(Utf8ScanInstr);
 };
 
@@ -6159,19 +6619,25 @@
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
+#define FIELD_LIST(F)                                                          \
+  F(StoreBarrierType, emit_store_barrier_)                                     \
+  F(const bool, index_unboxed_)                                                \
+  F(const intptr_t, index_scale_)                                              \
+  F(const intptr_t, class_id_)                                                 \
+  F(const AlignmentType, alignment_)                                           \
+  F(const TokenPosition, token_pos_)                                           \
+  F(const SpeculativeMode, speculative_mode_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(StoreIndexedInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   compiler::Assembler::CanBeSmi CanValueBeSmi() const {
     return compiler::Assembler::kValueCanBeSmi;
   }
 
-  StoreBarrierType emit_store_barrier_;
-  const bool index_unboxed_;
-  const intptr_t index_scale_;
-  const intptr_t class_id_;
-  const AlignmentType alignment_;
-  const TokenPosition token_pos_;
-  const SpeculativeMode speculative_mode_;
-
   DISALLOW_COPY_AND_ASSIGN(StoreIndexedInstr);
 };
 
@@ -6192,11 +6658,17 @@
   virtual bool HasUnknownSideEffects() const { return false; }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
- private:
-  const Array& coverage_array_;
-  const intptr_t coverage_index_;
-  const TokenPosition token_pos_;
+#define FIELD_LIST(F)                                                          \
+  F(const Array&, coverage_array_)                                             \
+  F(const intptr_t, coverage_index_)                                           \
+  F(const TokenPosition, token_pos_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(RecordCoverageInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(RecordCoverageInstr);
 };
 
@@ -6216,6 +6688,8 @@
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
+  DECLARE_EMPTY_SERIALIZATION(BooleanNegateInstr, TemplateDefinition)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateInstr);
 };
@@ -6255,12 +6729,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const TokenPosition token_pos_;
-  Value* value_;
-  Value* type_arguments_;
-  const AbstractType& type_;
+#define FIELD_LIST(F)                                                          \
+  F(const TokenPosition, token_pos_)                                           \
+  F(const AbstractType&, type_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(InstanceOfInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(InstanceOfInstr);
 };
 
@@ -6324,10 +6802,16 @@
 
   DECLARE_ABSTRACT_INSTRUCTION(Allocation);
 
- private:
-  const TokenPosition token_pos_;
-  AliasIdentity identity_;
+#define FIELD_LIST(F)                                                          \
+  F(const TokenPosition, token_pos_)                                           \
+  F(AliasIdentity, identity_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(AllocationInstr,
+                                          Definition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(AllocationInstr);
 };
 
@@ -6341,6 +6825,8 @@
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
+  DECLARE_EMPTY_SERIALIZATION(TemplateAllocation, AllocationInstr)
+
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
@@ -6362,6 +6848,7 @@
       : AllocationInstr(source, deopt_id),
         cls_(cls),
         has_type_arguments_(type_arguments != nullptr),
+        type_arguments_slot_(nullptr),
         type_arguments_(type_arguments) {
     ASSERT(cls.IsZoneHandle());
     ASSERT(!cls.IsNull());
@@ -6401,16 +6888,23 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F)                                                          \
+  F(const Class&, cls_)                                                        \
+  F(const bool, has_type_arguments_)                                           \
+  F(const Slot*, type_arguments_slot_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(AllocateObjectInstr,
+                                          AllocationInstr,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     ASSERT(has_type_arguments_ && (i == kTypeArgumentsPos));
     type_arguments_ = value;
   }
 
-  const Class& cls_;
-  const bool has_type_arguments_;
-  Value* type_arguments_;
-  const Slot* type_arguments_slot_ = nullptr;
+  Value* type_arguments_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectInstr);
 };
@@ -6462,6 +6956,8 @@
         compiler::target::Closure::InstanceSize());
   }
 
+  DECLARE_EMPTY_SERIALIZATION(AllocateClosureInstr, TemplateAllocation)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(AllocateClosureInstr);
 };
@@ -6488,9 +6984,14 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const intptr_t num_context_variables_;
+#define FIELD_LIST(F) F(const intptr_t, num_context_variables_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(AllocateUninitializedContextInstr,
+                                          TemplateAllocation,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(AllocateUninitializedContextInstr);
 };
 
@@ -6505,13 +7006,11 @@
                          const ZoneGrowableArray<const Slot*>& slots,
                          InputsArray&& values)
       : VariadicDefinition(std::move(values)),
-        allocation_(allocation),
         cls_(cls),
         num_elements_(num_elements),
         slots_(slots),
-        locations_(nullptr),
-        visited_for_liveness_(false),
-        registers_remapped_(false) {
+        registers_remapped_(false),
+        allocation_(allocation) {
     ASSERT(slots_.length() == InputCount());
   }
 
@@ -6524,7 +7023,10 @@
     return slots_[i]->offset_in_bytes();
   }
 
-  const Location& LocationAt(intptr_t i) { return locations_[i]; }
+  const Location& LocationAt(intptr_t i) {
+    ASSERT(0 <= i && i < InputCount());
+    return locations_[i];
+  }
 
   DECLARE_INSTRUCTION(MaterializeObject)
 
@@ -6553,15 +7055,24 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  AllocationInstr* allocation_;
-  const Class& cls_;
-  intptr_t num_elements_;
-  const ZoneGrowableArray<const Slot*>& slots_;
-  Location* locations_;
+#define FIELD_LIST(F)                                                          \
+  F(const Class&, cls_)                                                        \
+  F(intptr_t, num_elements_)                                                   \
+  F(const ZoneGrowableArray<const Slot*>&, slots_)                             \
+  F(bool, registers_remapped_)
 
-  bool visited_for_liveness_;
-  bool registers_remapped_;
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(MaterializeObjectInstr,
+                                          VariadicDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+  DECLARE_EXTRA_SERIALIZATION
+
+ private:
+  Location* locations_ = nullptr;
+
+  // Not serialized.
+  AllocationInstr* allocation_ = nullptr;
+  bool visited_for_liveness_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(MaterializeObjectInstr);
 };
@@ -6583,6 +7094,8 @@
 
   DECLARE_ABSTRACT_INSTRUCTION(ArrayAllocation);
 
+  DECLARE_EMPTY_SERIALIZATION(ArrayAllocationInstr, AllocationInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ArrayAllocationInstr);
 };
@@ -6597,11 +7110,15 @@
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
+  DECLARE_EMPTY_SERIALIZATION(TemplateArrayAllocation, ArrayAllocationInstr)
+
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
+
+  DISALLOW_COPY_AND_ASSIGN(TemplateArrayAllocation);
 };
 
 class CreateArrayInstr : public TemplateArrayAllocation<2> {
@@ -6643,6 +7160,8 @@
     }
   }
 
+  DECLARE_EMPTY_SERIALIZATION(CreateArrayInstr, TemplateArrayAllocation)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(CreateArrayInstr);
 };
@@ -6681,9 +7200,14 @@
     }
   }
 
- private:
-  const classid_t class_id_;
+#define FIELD_LIST(F) F(const classid_t, class_id_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(AllocateTypedDataInstr,
+                                          TemplateArrayAllocation,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(AllocateTypedDataInstr);
 };
 
@@ -6720,9 +7244,14 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  intptr_t offset_;
+#define FIELD_LIST(F) F(const intptr_t, offset_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(LoadUntaggedInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(LoadUntaggedInstr);
 };
 
@@ -6754,10 +7283,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const Representation representation_;
-  const bool input_can_be_smi_;
+#define FIELD_LIST(F)                                                          \
+  F(const Representation, representation_)                                     \
+  F(const bool, input_can_be_smi_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(LoadClassIdInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(LoadClassIdInstr);
 };
 
@@ -6837,6 +7372,13 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F) F(const Slot&, slot_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(LoadFieldInstr,
+                                          TemplateLoadField,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   intptr_t OffsetInBytes() const { return slot().offset_in_bytes(); }
 
@@ -6844,8 +7386,6 @@
   // calls initializer if it is not. Field value is already loaded.
   void EmitNativeCodeForInitializerCall(FlowGraphCompiler* compiler);
 
-  const Slot& slot_;
-
   DISALLOW_COPY_AND_ASSIGN(LoadFieldInstr);
 };
 
@@ -6883,10 +7423,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const TokenPosition token_pos_;
-  const AbstractType& type_;
+#define FIELD_LIST(F)                                                          \
+  F(const TokenPosition, token_pos_)                                           \
+  F(const AbstractType&, type_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(InstantiateTypeInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeInstr);
 };
 
@@ -6969,11 +7515,17 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const TokenPosition token_pos_;
-  const Class& instantiator_class_;
-  const Function& function_;
+#define FIELD_LIST(F)                                                          \
+  F(const TokenPosition, token_pos_)                                           \
+  F(const Class&, instantiator_class_)                                         \
+  F(const Function&, function_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(InstantiateTypeArgumentsInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeArgumentsInstr);
 };
 
@@ -7006,9 +7558,14 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const ZoneGrowableArray<const Slot*>& context_slots_;
+#define FIELD_LIST(F) F(const ZoneGrowableArray<const Slot*>&, context_slots_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(AllocateContextInstr,
+                                          TemplateAllocation,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(AllocateContextInstr);
 };
 
@@ -7049,10 +7606,16 @@
 
   virtual bool HasUnknownSideEffects() const { return false; }
 
- private:
-  const TokenPosition token_pos_;
-  const ZoneGrowableArray<const Slot*>& context_slots_;
+#define FIELD_LIST(F)                                                          \
+  F(const TokenPosition, token_pos_)                                           \
+  F(const ZoneGrowableArray<const Slot*>&, context_slots_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(CloneContextInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(CloneContextInstr);
 };
 
@@ -7077,9 +7640,14 @@
 
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
- private:
-  bool licm_hoisted_;
+#define FIELD_LIST(F) F(bool, licm_hoisted_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(CheckEitherNonSmiInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(CheckEitherNonSmiInstr);
 };
 
@@ -7130,6 +7698,13 @@
     return kNotSpeculative;
   }
 
+#define FIELD_LIST(F) F(const Representation, from_representation_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(BoxInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  protected:
   BoxInstr(Representation from_representation, Value* value)
       : from_representation_(from_representation) {
@@ -7141,8 +7716,6 @@
     return Boxing::ValueOffset(from_representation());
   }
 
-  const Representation from_representation_;
-
   DISALLOW_COPY_AND_ASSIGN(BoxInstr);
 };
 
@@ -7164,6 +7737,8 @@
 
   DECLARE_ABSTRACT_INSTRUCTION(BoxInteger)
 
+  DECLARE_EMPTY_SERIALIZATION(BoxIntegerInstr, BoxInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxIntegerInstr);
 };
@@ -7180,6 +7755,8 @@
 
   DECLARE_INSTRUCTION(BoxSmallInt)
 
+  DECLARE_EMPTY_SERIALIZATION(BoxSmallIntInstr, BoxIntegerInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxSmallIntInstr);
 };
@@ -7191,6 +7768,8 @@
 
   DECLARE_INSTRUCTION_BACKEND()
 
+  DECLARE_EMPTY_SERIALIZATION(BoxInteger32Instr, BoxIntegerInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxInteger32Instr);
 };
@@ -7202,6 +7781,8 @@
 
   DECLARE_INSTRUCTION_NO_BACKEND(BoxInt32)
 
+  DECLARE_EMPTY_SERIALIZATION(BoxInt32Instr, BoxInteger32Instr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxInt32Instr);
 };
@@ -7213,6 +7794,8 @@
 
   DECLARE_INSTRUCTION_NO_BACKEND(BoxUint32)
 
+  DECLARE_EMPTY_SERIALIZATION(BoxUint32Instr, BoxInteger32Instr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxUint32Instr);
 };
@@ -7226,6 +7809,8 @@
 
   DECLARE_INSTRUCTION(BoxInt64)
 
+  DECLARE_EMPTY_SERIALIZATION(BoxInt64Instr, BoxIntegerInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxInt64Instr);
 };
@@ -7279,6 +7864,15 @@
 
   virtual TokenPosition token_pos() const { return TokenPosition::kBox; }
 
+#define FIELD_LIST(F)                                                          \
+  F(const Representation, representation_)                                     \
+  F(SpeculativeMode, speculative_mode_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(UnboxInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  protected:
   UnboxInstr(Representation representation,
              Value* value,
@@ -7290,6 +7884,10 @@
     SetInputAt(0, value);
   }
 
+  void set_speculative_mode(SpeculativeMode value) {
+    speculative_mode_ = value;
+  }
+
  private:
   bool CanConvertSmi() const;
   void EmitLoadFromBox(FlowGraphCompiler* compiler);
@@ -7302,10 +7900,6 @@
 
   intptr_t ValueOffset() const { return Boxing::ValueOffset(representation_); }
 
- protected:
-  const Representation representation_;
-  SpeculativeMode speculative_mode_;
-
   DISALLOW_COPY_AND_ASSIGN(UnboxInstr);
 };
 
@@ -7339,9 +7933,14 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  bool is_truncating_;
+#define FIELD_LIST(F) F(bool, is_truncating_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(UnboxIntegerInstr,
+                                          UnboxInstr,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(UnboxIntegerInstr);
 };
 
@@ -7360,6 +7959,8 @@
 
   DECLARE_INSTRUCTION_BACKEND()
 
+  DECLARE_EMPTY_SERIALIZATION(UnboxInteger32Instr, UnboxIntegerInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxInteger32Instr);
 };
@@ -7383,6 +7984,8 @@
 
   DECLARE_INSTRUCTION_NO_BACKEND(UnboxUint32)
 
+  DECLARE_EMPTY_SERIALIZATION(UnboxUint32Instr, UnboxInteger32Instr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxUint32Instr);
 };
@@ -7407,6 +8010,8 @@
 
   DECLARE_INSTRUCTION_NO_BACKEND(UnboxInt32)
 
+  DECLARE_EMPTY_SERIALIZATION(UnboxInt32Instr, UnboxInteger32Instr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxInt32Instr);
 };
@@ -7436,6 +8041,8 @@
 
   DECLARE_INSTRUCTION_NO_BACKEND(UnboxInt64)
 
+  DECLARE_EMPTY_SERIALIZATION(UnboxInt64Instr, UnboxIntegerInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxInt64Instr);
 };
@@ -7494,16 +8101,21 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const MathUnaryKind kind_;
+#define FIELD_LIST(F) F(const MathUnaryKind, kind_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(MathUnaryInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(MathUnaryInstr);
 };
 
 // Calls into the runtime and performs a case-insensitive comparison of the
 // UTF16 strings (i.e. TwoByteString or ExternalTwoByteString) located at
 // str[lhs_index:lhs_index + length] and str[rhs_index:rhs_index + length].
-// Depending on the runtime entry passed, we will treat the strings as either
+// Depending on [handle_surrogates], we will treat the strings as either
 // UCS2 (no surrogate handling) or UTF16 (surrogates handled appropriately).
 class CaseInsensitiveCompareInstr
     : public TemplateDefinition<4, NoThrow, Pure> {
@@ -7512,9 +8124,9 @@
                               Value* lhs_index,
                               Value* rhs_index,
                               Value* length,
-                              const RuntimeEntry& entry,
+                              bool handle_surrogates,
                               intptr_t cid)
-      : entry_(entry), cid_(cid) {
+      : handle_surrogates_(handle_surrogates), cid_(cid) {
     ASSERT(cid == kTwoByteStringCid || cid == kExternalTwoByteStringCid);
     ASSERT(index_scale() == 2);
     SetInputAt(0, str);
@@ -7528,7 +8140,7 @@
   Value* rhs_index() const { return inputs_[2]; }
   Value* length() const { return inputs_[3]; }
 
-  const RuntimeEntry& TargetFunction() const { return entry_; }
+  const RuntimeEntry& TargetFunction() const;
   bool IsExternal() const { return cid_ == kExternalTwoByteStringCid; }
   intptr_t class_id() const { return cid_; }
 
@@ -7544,13 +8156,21 @@
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(const Instruction& other) const {
-    return other.AsCaseInsensitiveCompare()->cid_ == cid_;
+    const auto* other_compare = other.AsCaseInsensitiveCompare();
+    return (other_compare->handle_surrogates_ == handle_surrogates_) &&
+           (other_compare->cid_ == cid_);
   }
 
- private:
-  const RuntimeEntry& entry_;
-  const intptr_t cid_;
+#define FIELD_LIST(F)                                                          \
+  F(const bool, handle_surrogates_)                                            \
+  F(const intptr_t, cid_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(CaseInsensitiveCompareInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(CaseInsensitiveCompareInstr);
 };
 
@@ -7605,10 +8225,16 @@
   virtual CompileType ComputeType() const;
   virtual bool AttributesEqual(const Instruction& other) const;
 
- private:
-  const MethodRecognizer::Kind op_kind_;
-  const intptr_t result_cid_;
+#define FIELD_LIST(F)                                                          \
+  F(const MethodRecognizer::Kind, op_kind_)                                    \
+  F(const intptr_t, result_cid_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(MathMinMaxInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(MathMinMaxInstr);
 };
 
@@ -7667,11 +8293,17 @@
            (speculative_mode_ == other_bin_op->speculative_mode_);
   }
 
- private:
-  const Token::Kind op_kind_;
-  const TokenPosition token_pos_;
-  const SpeculativeMode speculative_mode_;
+#define FIELD_LIST(F)                                                          \
+  F(const Token::Kind, op_kind_)                                               \
+  F(const TokenPosition, token_pos_)                                           \
+  F(const SpeculativeMode, speculative_mode_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(BinaryDoubleOpInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(BinaryDoubleOpInstr);
 };
 
@@ -7711,9 +8343,14 @@
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
- private:
-  const MethodRecognizer::Kind op_kind_;
+#define FIELD_LIST(F) F(const MethodRecognizer::Kind, op_kind_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(DoubleTestOpInstr,
+                                          TemplateComparison,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(DoubleTestOpInstr);
 };
 
@@ -7748,8 +8385,15 @@
 
   DECLARE_ABSTRACT_INSTRUCTION(UnaryIntegerOp)
 
+#define FIELD_LIST(F) F(const Token::Kind, op_kind_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(UnaryIntegerOpInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
-  const Token::Kind op_kind_;
+  DISALLOW_COPY_AND_ASSIGN(UnaryIntegerOpInstr);
 };
 
 // Handles both Smi operations: BIT_OR and NEGATE.
@@ -7766,6 +8410,8 @@
 
   DECLARE_INSTRUCTION(UnarySmiOp)
 
+  DECLARE_EMPTY_SERIALIZATION(UnarySmiOpInstr, UnaryIntegerOpInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(UnarySmiOpInstr);
 };
@@ -7794,6 +8440,8 @@
 
   DECLARE_INSTRUCTION(UnaryUint32Op)
 
+  DECLARE_EMPTY_SERIALIZATION(UnaryUint32OpInstr, UnaryIntegerOpInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(UnaryUint32OpInstr);
 };
@@ -7832,8 +8480,14 @@
 
   DECLARE_INSTRUCTION(UnaryInt64Op)
 
+#define FIELD_LIST(F) F(const SpeculativeMode, speculative_mode_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(UnaryInt64OpInstr,
+                                          UnaryIntegerOpInstr,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
-  const SpeculativeMode speculative_mode_;
   DISALLOW_COPY_AND_ASSIGN(UnaryInt64OpInstr);
 };
 
@@ -7902,6 +8556,16 @@
 
   DECLARE_ABSTRACT_INSTRUCTION(BinaryIntegerOp)
 
+#define FIELD_LIST(F)                                                          \
+  F(const Token::Kind, op_kind_)                                               \
+  F(bool, can_overflow_)                                                       \
+  F(bool, is_truncating_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(BinaryIntegerOpInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  protected:
   void InferRangeHelper(const Range* left_range,
                         const Range* right_range,
@@ -7910,11 +8574,6 @@
  private:
   Definition* CreateConstantResult(FlowGraph* graph, const Integer& result);
 
-  const Token::Kind op_kind_;
-
-  bool can_overflow_;
-  bool is_truncating_;
-
   DISALLOW_COPY_AND_ASSIGN(BinaryIntegerOpInstr);
 };
 
@@ -7938,9 +8597,14 @@
 
   Range* right_range() const { return right_range_; }
 
- private:
-  Range* right_range_;
+#define FIELD_LIST(F) F(Range*, right_range_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(BinarySmiOpInstr,
+                                          BinaryIntegerOpInstr,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(BinarySmiOpInstr);
 };
 
@@ -7996,6 +8660,8 @@
 
   DECLARE_INSTRUCTION(BinaryInt32Op)
 
+  DECLARE_EMPTY_SERIALIZATION(BinaryInt32OpInstr, BinaryIntegerOpInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BinaryInt32OpInstr);
 };
@@ -8038,6 +8704,8 @@
 
   DECLARE_INSTRUCTION(BinaryUint32Op)
 
+  DECLARE_EMPTY_SERIALIZATION(BinaryUint32OpInstr, BinaryIntegerOpInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(BinaryUint32OpInstr);
 };
@@ -8083,8 +8751,14 @@
 
   DECLARE_INSTRUCTION(BinaryInt64Op)
 
+#define FIELD_LIST(F) F(const SpeculativeMode, speculative_mode_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(BinaryInt64OpInstr,
+                                          BinaryIntegerOpInstr,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
-  const SpeculativeMode speculative_mode_;
   DISALLOW_COPY_AND_ASSIGN(BinaryInt64OpInstr);
 };
 
@@ -8113,6 +8787,13 @@
 
   DECLARE_ABSTRACT_INSTRUCTION(ShiftIntegerOp)
 
+#define FIELD_LIST(F) F(Range*, shift_range_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(ShiftIntegerOpInstr,
+                                          BinaryIntegerOpInstr,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  protected:
   static const intptr_t kShiftCountLimit = 63;
 
@@ -8121,8 +8802,6 @@
   bool IsShiftCountInRange(int64_t max = kShiftCountLimit) const;
 
  private:
-  Range* shift_range_;
-
   DISALLOW_COPY_AND_ASSIGN(ShiftIntegerOpInstr);
 };
 
@@ -8154,6 +8833,8 @@
 
   DECLARE_INSTRUCTION(ShiftInt64Op)
 
+  DECLARE_EMPTY_SERIALIZATION(ShiftInt64OpInstr, ShiftIntegerOpInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ShiftInt64OpInstr);
 };
@@ -8185,6 +8866,8 @@
 
   DECLARE_INSTRUCTION(SpeculativeShiftInt64Op)
 
+  DECLARE_EMPTY_SERIALIZATION(SpeculativeShiftInt64OpInstr, ShiftIntegerOpInstr)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(SpeculativeShiftInt64OpInstr);
 };
@@ -8217,6 +8900,8 @@
 
   DECLARE_INSTRUCTION(ShiftUint32Op)
 
+  DECLARE_EMPTY_SERIALIZATION(ShiftUint32OpInstr, ShiftIntegerOpInstr)
+
  private:
   static const intptr_t kUint32ShiftCountLimit = 31;
 
@@ -8247,6 +8932,9 @@
 
   virtual CompileType ComputeType() const;
 
+  DECLARE_EMPTY_SERIALIZATION(SpeculativeShiftUint32OpInstr,
+                              ShiftIntegerOpInstr)
+
  private:
   static const intptr_t kUint32ShiftCountLimit = 31;
 
@@ -8298,10 +8986,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const Token::Kind op_kind_;
-  const SpeculativeMode speculative_mode_;
+#define FIELD_LIST(F)                                                          \
+  F(const Token::Kind, op_kind_)                                               \
+  F(const SpeculativeMode, speculative_mode_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(UnaryDoubleOpInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(UnaryDoubleOpInstr);
 };
 
@@ -8352,12 +9046,18 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const TokenPosition token_pos_;
-  const intptr_t stack_depth_;
-  const intptr_t loop_depth_;
-  const Kind kind_;
+#define FIELD_LIST(F)                                                          \
+  F(const TokenPosition, token_pos_)                                           \
+  F(const intptr_t, stack_depth_)                                              \
+  F(const intptr_t, loop_depth_)                                               \
+  F(const Kind, kind_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(CheckStackOverflowInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowInstr);
 };
 
@@ -8381,9 +9081,14 @@
 
   virtual bool AttributesEqual(const Instruction& other) const { return true; }
 
- private:
-  const TokenPosition token_pos_;
+#define FIELD_LIST(F) F(const TokenPosition, token_pos_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(SmiToDoubleInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(SmiToDoubleInstr);
 };
 
@@ -8407,6 +9112,8 @@
 
   virtual bool AttributesEqual(const Instruction& other) const { return true; }
 
+  DECLARE_EMPTY_SERIALIZATION(Int32ToDoubleInstr, TemplateDefinition)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Int32ToDoubleInstr);
 };
@@ -8448,9 +9155,14 @@
     return speculative_mode_ == other.AsInt64ToDouble()->speculative_mode_;
   }
 
- private:
-  const SpeculativeMode speculative_mode_;
+#define FIELD_LIST(F) F(const SpeculativeMode, speculative_mode_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(Int64ToDoubleInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(Int64ToDoubleInstr);
 };
 
@@ -8495,9 +9207,14 @@
     return other.AsDoubleToInteger()->recognized_kind() == recognized_kind();
   }
 
- private:
-  const MethodRecognizer::Kind recognized_kind_;
+#define FIELD_LIST(F) F(const MethodRecognizer::Kind, recognized_kind_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(DoubleToIntegerInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(DoubleToIntegerInstr);
 };
 
@@ -8526,6 +9243,8 @@
 
   virtual bool AttributesEqual(const Instruction& other) const { return true; }
 
+  DECLARE_EMPTY_SERIALIZATION(DoubleToSmiInstr, TemplateDefinition)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(DoubleToSmiInstr);
 };
@@ -8569,9 +9288,14 @@
     return other.AsDoubleToDouble()->recognized_kind() == recognized_kind();
   }
 
- private:
-  const MethodRecognizer::Kind recognized_kind_;
+#define FIELD_LIST(F) F(const MethodRecognizer::Kind, recognized_kind_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(DoubleToDoubleInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(DoubleToDoubleInstr);
 };
 
@@ -8609,9 +9333,14 @@
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
- private:
-  const SpeculativeMode speculative_mode_;
+#define FIELD_LIST(F) F(const SpeculativeMode, speculative_mode_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(DoubleToFloatInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(DoubleToFloatInstr);
 };
 
@@ -8643,6 +9372,8 @@
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
+  DECLARE_EMPTY_SERIALIZATION(FloatToDoubleInstr, TemplateDefinition)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(FloatToDoubleInstr);
 };
@@ -8698,10 +9429,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const MethodRecognizer::Kind recognized_kind_;
-  const TokenPosition token_pos_;
+#define FIELD_LIST(F)                                                          \
+  F(const MethodRecognizer::Kind, recognized_kind_)                            \
+  F(const TokenPosition, token_pos_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(InvokeMathCFunctionInstr,
+                                          VariadicDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(InvokeMathCFunctionInstr);
 };
 
@@ -8746,10 +9483,17 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F)                                                          \
+  F(const intptr_t, index_)                                                    \
+  F(const Representation, definition_rep_)                                     \
+  F(const intptr_t, definition_cid_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(ExtractNthOutputInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
-  const intptr_t index_;
-  const Representation definition_rep_;
-  const intptr_t definition_cid_;
   DISALLOW_COPY_AND_ASSIGN(ExtractNthOutputInstr);
 };
 
@@ -8778,6 +9522,8 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+  DECLARE_EMPTY_SERIALIZATION(TruncDivModInstr, TemplateDefinition)
+
  private:
   Range* divisor_range() const {
     // Note: this range is only used to remove check for zero divisor from
@@ -8832,12 +9578,18 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const Cids& cids_;
-  bool licm_hoisted_;
-  bool is_bit_test_;
-  const TokenPosition token_pos_;
+#define FIELD_LIST(F)                                                          \
+  F(const Cids&, cids_)                                                        \
+  F(bool, licm_hoisted_)                                                       \
+  F(bool, is_bit_test_)                                                        \
+  F(const TokenPosition, token_pos_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(CheckClassInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   int EmitCheckCid(FlowGraphCompiler* compiler,
                    int bias,
                    intptr_t cid_start,
@@ -8881,10 +9633,16 @@
   bool licm_hoisted() const { return licm_hoisted_; }
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
- private:
-  const TokenPosition token_pos_;
-  bool licm_hoisted_;
+#define FIELD_LIST(F)                                                          \
+  F(const TokenPosition, token_pos_)                                           \
+  F(bool, licm_hoisted_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(CheckSmiInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(CheckSmiInstr);
 };
 
@@ -8944,11 +9702,17 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const TokenPosition token_pos_;
-  const String& function_name_;
-  const ExceptionType exception_type_;
+#define FIELD_LIST(F)                                                          \
+  F(const TokenPosition, token_pos_)                                           \
+  F(const String&, function_name_)                                             \
+  F(const ExceptionType, exception_type_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(CheckNullInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(CheckNullInstr);
 };
 
@@ -8977,11 +9741,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F) F(CidRangeValue, cids_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(CheckClassIdInstr,
+                                          TemplateInstruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   bool Contains(intptr_t cid) const;
 
-  CidRangeValue cids_;
-
   DISALLOW_COPY_AND_ASSIGN(CheckClassIdInstr);
 };
 
@@ -9011,6 +9780,8 @@
   // Give a name to the location/input indices.
   enum { kLengthPos = 0, kIndexPos = 1 };
 
+  DECLARE_EMPTY_SERIALIZATION(CheckBoundBase, TemplateDefinition)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(CheckBoundBase);
 };
@@ -9045,10 +9816,16 @@
 
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
- private:
-  bool generalized_;
-  bool licm_hoisted_;
+#define FIELD_LIST(F)                                                          \
+  F(bool, generalized_)                                                        \
+  F(bool, licm_hoisted_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(CheckArrayBoundInstr,
+                                          CheckBoundBase,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(CheckArrayBoundInstr);
 };
 
@@ -9102,6 +9879,8 @@
     return SlowPathSharingSupported(is_optimizing);
   }
 
+  DECLARE_EMPTY_SERIALIZATION(GenericCheckBoundInstr, CheckBoundBase)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(GenericCheckBoundInstr);
 };
@@ -9127,6 +9906,8 @@
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
+  DECLARE_EMPTY_SERIALIZATION(CheckWritableInstr, TemplateDefinition)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(CheckWritableInstr);
 };
@@ -9167,13 +9948,19 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F) F(ComparisonInstr*, comparison_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(CheckConditionInstr,
+                                          Instruction,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+  DECLARE_EXTRA_SERIALIZATION
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     comparison()->RawSetInputAt(i, value);
   }
 
-  ComparisonInstr* comparison_;
-
   DISALLOW_COPY_AND_ASSIGN(CheckConditionInstr);
 };
 
@@ -9238,11 +10025,17 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const Representation from_representation_;
-  const Representation to_representation_;
-  bool is_truncating_;
+#define FIELD_LIST(F)                                                          \
+  F(const Representation, from_representation_)                                \
+  F(const Representation, to_representation_)                                  \
+  F(bool, is_truncating_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(IntConverterInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(IntConverterInstr);
 };
 
@@ -9289,10 +10082,16 @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const Representation from_representation_;
-  const Representation to_representation_;
+#define FIELD_LIST(F)                                                          \
+  F(const Representation, from_representation_)                                \
+  F(const Representation, to_representation_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(BitCastInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(BitCastInstr);
 };
 
@@ -9318,6 +10117,8 @@
 
   DECLARE_INSTRUCTION(LoadThread);
 
+  DECLARE_EMPTY_SERIALIZATION(LoadThreadInstr, TemplateDefinition)
+
  private:
   DISALLOW_COPY_AND_ASSIGN(LoadThreadInstr);
 };
@@ -9526,6 +10327,13 @@
   DECLARE_INSTRUCTION(SimdOp)
   PRINT_OPERANDS_TO_SUPPORT
 
+#define FIELD_LIST(F)                                                          \
+  F(const Kind, kind_)                                                         \
+  F(intptr_t, mask_)
+
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(SimdOpInstr, Definition, FIELD_LIST)
+#undef FIELD_LIST
+
  private:
   SimdOpInstr(Kind kind, intptr_t deopt_id)
       : Definition(deopt_id), kind_(kind) {}
@@ -9549,9 +10357,7 @@
   // We consider SimdOpInstr to be very uncommon so we don't optimize them for
   // size. Any instance of SimdOpInstr has enough space to fit any variation.
   // TODO(dartbug.com/30949) optimize this for size.
-  const Kind kind_;
   Value* inputs_[4];
-  intptr_t mask_;
 
   DISALLOW_COPY_AND_ASSIGN(SimdOpInstr);
 };
@@ -9590,10 +10396,16 @@
   DECLARE_INSTRUCTION(Call1ArgStub);
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const StubId stub_id_;
-  const TokenPosition token_pos_;
+#define FIELD_LIST(F)                                                          \
+  F(const StubId, stub_id_)                                                    \
+  F(const TokenPosition, token_pos_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(Call1ArgStubInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(Call1ArgStubInstr);
 };
 
@@ -9634,11 +10446,17 @@
   DECLARE_INSTRUCTION(Suspend);
   PRINT_OPERANDS_TO_SUPPORT
 
- private:
-  const StubId stub_id_;
-  const intptr_t resume_deopt_id_;
-  const TokenPosition token_pos_;
+#define FIELD_LIST(F)                                                          \
+  F(const StubId, stub_id_)                                                    \
+  F(const intptr_t, resume_deopt_id_)                                          \
+  F(const TokenPosition, token_pos_)
 
+  DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(SuspendInstr,
+                                          TemplateDefinition,
+                                          FIELD_LIST)
+#undef FIELD_LIST
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(SuspendInstr);
 };
 
@@ -9851,6 +10669,9 @@
   // from the copy.
   Environment* DeepCopy(Zone* zone, intptr_t length) const;
 
+  void Write(FlowGraphSerializer* s) const;
+  explicit Environment(FlowGraphDeserializer* d);
+
  private:
   friend class ShallowIterator;
   friend class compiler::BlockBuilder;  // For Environment constructor.
@@ -9969,6 +10790,9 @@
   ConstantInstr* constant = definition()->AsConstant();
   return (constant == nullptr) || constant->value().ptr() == value.ptr();
 }
+#undef DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS
+#undef DECLARE_CUSTOM_SERIALIZATION
+#undef DECLARE_EMPTY_SERIALIZATION
 
 }  // namespace dart
 
diff --git a/runtime/vm/compiler/backend/il_serializer.cc b/runtime/vm/compiler/backend/il_serializer.cc
new file mode 100644
index 0000000..6fb76fc
--- /dev/null
+++ b/runtime/vm/compiler/backend/il_serializer.cc
@@ -0,0 +1,2305 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#include "vm/compiler/backend/il_serializer.h"
+
+#include "vm/closure_functions_cache.h"
+#if defined(DART_PRECOMPILER)
+#include "vm/compiler/aot/precompiler.h"
+#endif
+#include "vm/compiler/backend/flow_graph.h"
+#include "vm/compiler/backend/il.h"
+#include "vm/compiler/backend/range_analysis.h"
+#include "vm/compiler/ffi/call.h"
+#include "vm/compiler/frontend/flow_graph_builder.h"
+#include "vm/object_store.h"
+#include "vm/parser.h"
+
+#define Z zone_
+
+// This file declares write/read methods for each type,
+// sorted alphabetically by type/class name (case-insensitive).
+// Each "write" method is followed by corresponding "read" method
+// or constructor.
+
+namespace dart {
+
+FlowGraphSerializer::FlowGraphSerializer(NonStreamingWriteStream* stream)
+    : stream_(stream),
+      zone_(Thread::Current()->zone()),
+      isolate_group_(IsolateGroup::Current()),
+      heap_(IsolateGroup::Current()->heap()) {}
+
+FlowGraphSerializer::~FlowGraphSerializer() {
+  heap_->ResetObjectIdTable();
+}
+
+FlowGraphDeserializer::FlowGraphDeserializer(
+    const ParsedFunction& parsed_function,
+    ReadStream* stream)
+    : parsed_function_(parsed_function),
+      stream_(stream),
+      zone_(Thread::Current()->zone()),
+      thread_(Thread::Current()),
+      isolate_group_(IsolateGroup::Current()) {}
+
+ClassPtr FlowGraphDeserializer::GetClassById(classid_t id) const {
+  return isolate_group()->class_table()->At(id);
+}
+
+template <>
+void FlowGraphSerializer::Write<const AbstractType*>(const AbstractType* x) {
+  if (x == nullptr) {
+    Write<bool>(false);
+  } else {
+    Write<bool>(true);
+    Write<const AbstractType&>(*x);
+  }
+}
+
+template <>
+const AbstractType* FlowGraphDeserializer::Read<const AbstractType*>() {
+  if (!Read<bool>()) {
+    return nullptr;
+  }
+  return &Read<const AbstractType&>();
+}
+
+template <>
+void FlowGraphSerializer::Write<AliasIdentity>(AliasIdentity x) {
+  x.Write(this);
+}
+
+template <>
+AliasIdentity FlowGraphDeserializer::Read<AliasIdentity>() {
+  return AliasIdentity(this);
+}
+
+void AliasIdentity::Write(FlowGraphSerializer* s) const {
+  s->Write<intptr_t>(value_);
+}
+
+AliasIdentity::AliasIdentity(FlowGraphDeserializer* d)
+    : value_(d->Read<intptr_t>()) {}
+
+void BlockEntryInstr::WriteTo(FlowGraphSerializer* s) {
+  TemplateInstruction::WriteTo(s);
+  s->Write<intptr_t>(block_id_);
+  s->Write<intptr_t>(try_index_);
+  s->Write<intptr_t>(stack_depth_);
+  s->Write<ParallelMoveInstr*>(parallel_move_);
+}
+
+BlockEntryInstr::BlockEntryInstr(FlowGraphDeserializer* d)
+    : TemplateInstruction(d),
+      block_id_(d->Read<intptr_t>()),
+      try_index_(d->Read<intptr_t>()),
+      stack_depth_(d->Read<intptr_t>()),
+      dominated_blocks_(1),
+      parallel_move_(d->Read<ParallelMoveInstr*>()) {
+  d->set_block(block_id_, this);
+  d->set_current_block(this);
+}
+
+void BlockEntryInstr::WriteExtra(FlowGraphSerializer* s) {
+  TemplateInstruction::WriteExtra(s);
+  s->WriteRef<BlockEntryInstr*>(dominator_);
+  s->WriteGrowableArrayOfRefs<BlockEntryInstr*>(dominated_blocks_);
+  if (parallel_move_ != nullptr) {
+    parallel_move_->WriteExtra(s);
+  }
+}
+
+void BlockEntryInstr::ReadExtra(FlowGraphDeserializer* d) {
+  TemplateInstruction::ReadExtra(d);
+  dominator_ = d->ReadRef<BlockEntryInstr*>();
+  dominated_blocks_ = d->ReadGrowableArrayOfRefs<BlockEntryInstr*>();
+  if (parallel_move_ != nullptr) {
+    parallel_move_->ReadExtra(d);
+  }
+}
+
+template <>
+void FlowGraphSerializer::WriteRef<BlockEntryInstr*>(BlockEntryInstr* x) {
+  ASSERT(can_write_refs());
+  if (x == nullptr) {
+    Write<intptr_t>(-1);
+    return;
+  }
+  const intptr_t id = x->block_id();
+  ASSERT(id >= 0);
+  Write<intptr_t>(id);
+}
+
+template <>
+BlockEntryInstr* FlowGraphDeserializer::ReadRef<BlockEntryInstr*>() {
+  const intptr_t id = Read<intptr_t>();
+  if (id < 0) {
+    return nullptr;
+  }
+  return block(id);
+}
+
+#define INSTRUCTION_REFS_SERIALIZABLE_AS_BLOCK_ENTRY(V)                        \
+  V(CatchBlockEntry, CatchBlockEntryInstr)                                     \
+  V(FunctionEntry, FunctionEntryInstr)                                         \
+  V(IndirectEntry, IndirectEntryInstr)                                         \
+  V(JoinEntry, JoinEntryInstr)                                                 \
+  V(OsrEntry, OsrEntryInstr)                                                   \
+  V(TargetEntry, TargetEntryInstr)
+
+#define SERIALIZABLE_AS_BLOCK_ENTRY(name, type)                                \
+  template <>                                                                  \
+  void FlowGraphSerializer::WriteRef<type*>(type * x) {                        \
+    WriteRef<BlockEntryInstr*>(x);                                             \
+  }                                                                            \
+  template <>                                                                  \
+  type* FlowGraphDeserializer::ReadRef<type*>() {                              \
+    BlockEntryInstr* instr = ReadRef<BlockEntryInstr*>();                      \
+    ASSERT((instr == nullptr) || instr->Is##name());                           \
+    return static_cast<type*>(instr);                                          \
+  }
+
+INSTRUCTION_REFS_SERIALIZABLE_AS_BLOCK_ENTRY(SERIALIZABLE_AS_BLOCK_ENTRY)
+#undef SERIALIZABLE_AS_BLOCK_ENTRY
+#undef INSTRUCTION_REFS_SERIALIZABLE_AS_BLOCK_ENTRY
+
+void BlockEntryWithInitialDefs::WriteTo(FlowGraphSerializer* s) {
+  BlockEntryInstr::WriteTo(s);
+  s->Write<GrowableArray<Definition*>>(initial_definitions_);
+}
+
+BlockEntryWithInitialDefs::BlockEntryWithInitialDefs(FlowGraphDeserializer* d)
+    : BlockEntryInstr(d),
+      initial_definitions_(d->Read<GrowableArray<Definition*>>()) {
+  for (Definition* def : initial_definitions_) {
+    def->set_previous(this);
+    if (auto par = def->AsParameter()) {
+      par->set_block(this);
+    }
+  }
+}
+
+void BlockEntryWithInitialDefs::WriteExtra(FlowGraphSerializer* s) {
+  BlockEntryInstr::WriteExtra(s);
+  for (Definition* def : initial_definitions_) {
+    def->WriteExtra(s);
+  }
+}
+
+void BlockEntryWithInitialDefs::ReadExtra(FlowGraphDeserializer* d) {
+  BlockEntryInstr::ReadExtra(d);
+  for (Definition* def : initial_definitions_) {
+    def->ReadExtra(d);
+  }
+}
+
+template <>
+void FlowGraphSerializer::Write<bool>(bool x) {
+  stream_->Write<uint8_t>(x ? 1 : 0);
+}
+
+template <>
+bool FlowGraphDeserializer::Read<bool>() {
+  return (stream_->Read<uint8_t>() != 0);
+}
+
+void BranchInstr::WriteExtra(FlowGraphSerializer* s) {
+  // Branch reuses inputs from its embedded Comparison.
+  // Instruction::WriteExtra is not called to avoid
+  // writing/reading inputs twice.
+  WriteExtraWithoutInputs(s);
+  comparison_->WriteExtra(s);
+  s->WriteRef<TargetEntryInstr*>(true_successor_);
+  s->WriteRef<TargetEntryInstr*>(false_successor_);
+  s->WriteRef<TargetEntryInstr*>(constant_target_);
+}
+
+void BranchInstr::ReadExtra(FlowGraphDeserializer* d) {
+  ReadExtraWithoutInputs(d);
+  comparison_->ReadExtra(d);
+  for (intptr_t i = comparison_->InputCount() - 1; i >= 0; --i) {
+    comparison_->InputAt(i)->set_instruction(this);
+  }
+  true_successor_ = d->ReadRef<TargetEntryInstr*>();
+  false_successor_ = d->ReadRef<TargetEntryInstr*>();
+  constant_target_ = d->ReadRef<TargetEntryInstr*>();
+}
+
+template <>
+void FlowGraphSerializer::Write<const compiler::ffi::CallbackMarshaller&>(
+    const compiler::ffi::CallbackMarshaller& x) {
+  UNIMPLEMENTED();
+}
+
+template <>
+const compiler::ffi::CallbackMarshaller&
+FlowGraphDeserializer::Read<const compiler::ffi::CallbackMarshaller&>() {
+  UNIMPLEMENTED();
+  return *compiler::ffi::CallbackMarshaller::FromFunction(
+      Z, Function::null_function(), nullptr);
+}
+
+template <>
+void FlowGraphSerializer::Write<const compiler::ffi::CallMarshaller&>(
+    const compiler::ffi::CallMarshaller& x) {
+  Write<const Function&>(x.dart_signature());
+}
+
+template <>
+const compiler::ffi::CallMarshaller&
+FlowGraphDeserializer::Read<const compiler::ffi::CallMarshaller&>() {
+  const Function& dart_signature = Read<const Function&>();
+  const char* error = nullptr;
+  return *compiler::ffi::CallMarshaller::FromFunction(Z, dart_signature,
+                                                      &error);
+}
+
+template <>
+void FlowGraphSerializer::Write<const CallTargets&>(const CallTargets& x) {
+  x.Write(this);
+}
+
+template <>
+const CallTargets& FlowGraphDeserializer::Read<const CallTargets&>() {
+  return *(new (Z) CallTargets(this));
+}
+
+void CallTargets::Write(FlowGraphSerializer* s) const {
+  const intptr_t len = cid_ranges_.length();
+  s->Write<intptr_t>(len);
+  for (intptr_t i = 0; i < len; ++i) {
+    TargetInfo* t = TargetAt(i);
+    s->Write<intptr_t>(t->cid_start);
+    s->Write<intptr_t>(t->cid_end);
+    s->Write<const Function&>(*(t->target));
+    s->Write<intptr_t>(t->count);
+    s->Write<int8_t>(t->exactness.Encode());
+  }
+}
+
+CallTargets::CallTargets(FlowGraphDeserializer* d) : Cids(d->zone()) {
+  const intptr_t len = d->Read<intptr_t>();
+  cid_ranges_.EnsureLength(len, nullptr);
+  for (intptr_t i = 0; i < len; ++i) {
+    const intptr_t cid_start = d->Read<intptr_t>();
+    const intptr_t cid_end = d->Read<intptr_t>();
+    const Function& target = d->Read<const Function&>();
+    const intptr_t count = d->Read<intptr_t>();
+    const StaticTypeExactnessState exactness =
+        StaticTypeExactnessState::Decode(d->Read<int8_t>());
+    TargetInfo* t = new (d->zone())
+        TargetInfo(cid_start, cid_end, &target, count, exactness);
+    cid_ranges_[i] = t;
+  }
+}
+
+void CatchBlockEntryInstr::WriteTo(FlowGraphSerializer* s) {
+  BlockEntryWithInitialDefs::WriteTo(s);
+  s->Write<const Array&>(catch_handler_types_);
+  s->Write<intptr_t>(catch_try_index_);
+  s->Write<bool>(needs_stacktrace_);
+  s->Write<bool>(is_generated_);
+}
+
+CatchBlockEntryInstr::CatchBlockEntryInstr(FlowGraphDeserializer* d)
+    : BlockEntryWithInitialDefs(d),
+      graph_entry_(d->graph_entry()),
+      predecessor_(nullptr),
+      catch_handler_types_(d->Read<const Array&>()),
+      catch_try_index_(d->Read<intptr_t>()),
+      exception_var_(nullptr),
+      stacktrace_var_(nullptr),
+      raw_exception_var_(nullptr),
+      raw_stacktrace_var_(nullptr),
+      needs_stacktrace_(d->Read<bool>()),
+      is_generated_(d->Read<bool>()) {}
+
+template <>
+void FlowGraphSerializer::Write<const char*>(const char* x) {
+  ASSERT(x != nullptr);
+  const intptr_t len = strlen(x);
+  Write<intptr_t>(len);
+  stream_->WriteBytes(x, len);
+}
+
+template <>
+const char* FlowGraphDeserializer::Read<const char*>() {
+  const intptr_t len = Read<intptr_t>();
+  char* str = zone()->Alloc<char>(len + 1);
+  stream_->ReadBytes(str, len);
+  str[len] = 0;
+  return str;
+}
+
+void CheckConditionInstr::WriteExtra(FlowGraphSerializer* s) {
+  // CheckCondition reuses inputs from its embedded Comparison.
+  // Instruction::WriteExtra is not called to avoid
+  // writing/reading inputs twice.
+  WriteExtraWithoutInputs(s);
+  comparison_->WriteExtra(s);
+}
+
+void CheckConditionInstr::ReadExtra(FlowGraphDeserializer* d) {
+  ReadExtraWithoutInputs(d);
+  comparison_->ReadExtra(d);
+  for (intptr_t i = comparison_->InputCount() - 1; i >= 0; --i) {
+    comparison_->InputAt(i)->set_instruction(this);
+  }
+}
+
+template <>
+void FlowGraphSerializer::Write<CidRangeValue>(CidRangeValue x) {
+  Write<intptr_t>(x.cid_start);
+  Write<intptr_t>(x.cid_end);
+}
+
+template <>
+CidRangeValue FlowGraphDeserializer::Read<CidRangeValue>() {
+  const intptr_t cid_start = Read<intptr_t>();
+  const intptr_t cid_end = Read<intptr_t>();
+  return CidRangeValue(cid_start, cid_end);
+}
+
+template <>
+void FlowGraphSerializer::Write<const Cids&>(const Cids& x) {
+  const intptr_t len = x.length();
+  Write<intptr_t>(len);
+  for (intptr_t i = 0; i < len; ++i) {
+    const CidRange* r = x.At(i);
+    Write<intptr_t>(r->cid_start);
+    Write<intptr_t>(r->cid_end);
+  }
+}
+
+template <>
+const Cids& FlowGraphDeserializer::Read<const Cids&>() {
+  Cids* cids = new (Z) Cids(Z);
+  const intptr_t len = Read<intptr_t>();
+  for (intptr_t i = 0; i < len; ++i) {
+    const intptr_t cid_start = Read<intptr_t>();
+    const intptr_t cid_end = Read<intptr_t>();
+    CidRange* r = new (Z) CidRange(cid_start, cid_end);
+    cids->Add(r);
+  }
+  return *cids;
+}
+
+template <>
+void FlowGraphSerializer::Write<const Class&>(const Class& x) {
+  if (x.IsNull()) {
+    Write<classid_t>(kIllegalCid);
+    return;
+  }
+  Write<classid_t>(x.id());
+}
+
+template <>
+const Class& FlowGraphDeserializer::Read<const Class&>() {
+  const classid_t cid = Read<classid_t>();
+  if (cid == kIllegalCid) {
+    return Class::ZoneHandle(Z);
+  }
+  return Class::ZoneHandle(Z, GetClassById(cid));
+}
+
+void ConstraintInstr::WriteExtra(FlowGraphSerializer* s) {
+  TemplateDefinition::WriteExtra(s);
+  s->WriteRef<TargetEntryInstr*>(target_);
+}
+
+void ConstraintInstr::ReadExtra(FlowGraphDeserializer* d) {
+  TemplateDefinition::ReadExtra(d);
+  target_ = d->ReadRef<TargetEntryInstr*>();
+}
+
+template <>
+void FlowGraphSerializer::Write<const Code&>(const Code& x) {
+  ASSERT(!x.IsNull());
+  ASSERT(x.IsStubCode());
+  for (intptr_t i = 0, n = StubCode::NumEntries(); i < n; ++i) {
+    if (StubCode::EntryAt(i).ptr() == x.ptr()) {
+      Write<intptr_t>(i);
+      return;
+    }
+  }
+  intptr_t index = StubCode::NumEntries();
+  ObjectStore* object_store = isolate_group()->object_store();
+#define MATCH(member, name)                                                    \
+  if (object_store->member() == x.ptr()) {                                     \
+    Write<intptr_t>(index);                                                    \
+    return;                                                                    \
+  }                                                                            \
+  ++index;
+  OBJECT_STORE_STUB_CODE_LIST(MATCH)
+#undef MATCH
+  UNIMPLEMENTED();
+}
+
+template <>
+const Code& FlowGraphDeserializer::Read<const Code&>() {
+  const intptr_t stub_id = Read<intptr_t>();
+  if (stub_id < StubCode::NumEntries()) {
+    return StubCode::EntryAt(stub_id);
+  }
+  intptr_t index = StubCode::NumEntries();
+  ObjectStore* object_store = isolate_group()->object_store();
+#define MATCH(member, name)                                                    \
+  if (index == stub_id) {                                                      \
+    return Code::ZoneHandle(Z, object_store->member());                        \
+  }                                                                            \
+  ++index;
+  OBJECT_STORE_STUB_CODE_LIST(MATCH)
+#undef MATCH
+  UNIMPLEMENTED();
+}
+
+template <>
+void FlowGraphSerializer::Write<CompileType*>(CompileType* x) {
+  if (x == nullptr) {
+    Write<bool>(false);
+  } else {
+    Write<bool>(true);
+    x->Write(this);
+  }
+}
+
+template <>
+CompileType* FlowGraphDeserializer::Read<CompileType*>() {
+  if (!Read<bool>()) {
+    return nullptr;
+  }
+  return new (Z) CompileType(this);
+}
+
+void CompileType::Write(FlowGraphSerializer* s) const {
+  s->Write<bool>(can_be_null_);
+  s->Write<bool>(can_be_sentinel_);
+  s->Write<classid_t>(cid_);
+  if (type_ == nullptr) {
+    s->Write<bool>(false);
+  } else {
+    s->Write<bool>(true);
+    s->Write<const AbstractType&>(*type_);
+  }
+}
+
+CompileType::CompileType(FlowGraphDeserializer* d)
+    : can_be_null_(d->Read<bool>()),
+      can_be_sentinel_(d->Read<bool>()),
+      cid_(d->Read<classid_t>()),
+      type_(nullptr) {
+  if (d->Read<bool>()) {
+    type_ = &d->Read<const AbstractType&>();
+  }
+}
+
+void Definition::WriteTo(FlowGraphSerializer* s) {
+  Instruction::WriteTo(s);
+  s->Write<Range*>(range_);
+  s->Write<intptr_t>(temp_index_);
+  s->Write<intptr_t>(ssa_temp_index_);
+  s->Write<CompileType*>(type_);
+}
+
+Definition::Definition(FlowGraphDeserializer* d)
+    : Instruction(d),
+      range_(d->Read<Range*>()),
+      temp_index_(d->Read<intptr_t>()),
+      ssa_temp_index_(d->Read<intptr_t>()),
+      type_(d->Read<CompileType*>()) {
+  if (HasSSATemp()) {
+    d->set_definition(ssa_temp_index(), this);
+  }
+  if (type_ != nullptr) {
+    type_->set_owner(this);
+  }
+}
+
+template <>
+void FlowGraphSerializer::WriteRef<Definition*>(Definition* x) {
+  if (!x->HasSSATemp()) {
+    if (auto* push_arg = x->AsPushArgument()) {
+      // Environments of the calls can reference PushArgument instructions
+      // and they don't have SSA temps.
+      // Write a reference to the original definition.
+      // When reading it is restored using RepairPushArgsInEnvironment.
+      x = push_arg->value()->definition();
+    } else {
+      UNREACHABLE();
+    }
+  }
+  ASSERT(x->HasSSATemp());
+  ASSERT(can_write_refs());
+  Write<intptr_t>(x->ssa_temp_index());
+}
+
+template <>
+Definition* FlowGraphDeserializer::ReadRef<Definition*>() {
+  return definition(Read<intptr_t>());
+}
+
+template <>
+void FlowGraphSerializer::Write<double>(double x) {
+  stream_->Write<int64_t>(bit_cast<int64_t>(x));
+}
+
+template <>
+double FlowGraphDeserializer::Read<double>() {
+  return bit_cast<double>(stream_->Read<int64_t>());
+}
+
+template <>
+void FlowGraphSerializer::Write<Environment*>(Environment* x) {
+  ASSERT(can_write_refs());
+  if (x == nullptr) {
+    Write<bool>(false);
+  } else {
+    Write<bool>(true);
+    x->Write(this);
+  }
+}
+
+template <>
+Environment* FlowGraphDeserializer::Read<Environment*>() {
+  if (!Read<bool>()) {
+    return nullptr;
+  }
+  return new (Z) Environment(this);
+}
+
+void Environment::Write(FlowGraphSerializer* s) const {
+  s->Write<GrowableArray<Value*>>(values_);
+  s->Write<intptr_t>(fixed_parameter_count_);
+  s->Write<uintptr_t>(bitfield_);
+  s->Write<const Function&>(function_);
+  s->Write<Environment*>(outer_);
+  if (locations_ == nullptr) {
+    s->Write<bool>(false);
+  } else {
+    s->Write<bool>(true);
+    for (intptr_t i = 0, n = values_.length(); i < n; ++i) {
+      locations_[i].Write(s);
+    }
+  }
+}
+
+Environment::Environment(FlowGraphDeserializer* d)
+    : values_(d->Read<GrowableArray<Value*>>()),
+      locations_(nullptr),
+      fixed_parameter_count_(d->Read<intptr_t>()),
+      bitfield_(d->Read<uintptr_t>()),
+      function_(d->Read<const Function&>()),
+      outer_(d->Read<Environment*>()) {
+  for (intptr_t i = 0, n = values_.length(); i < n; ++i) {
+    Value* value = values_[i];
+    value->definition()->AddEnvUse(value);
+  }
+  if (d->Read<bool>()) {
+    locations_ = d->zone()->Alloc<Location>(values_.length());
+    for (intptr_t i = 0, n = values_.length(); i < n; ++i) {
+      locations_[i] = Location::Read(d);
+    }
+  }
+}
+
+void FlowGraphSerializer::WriteFlowGraph(
+    const FlowGraph& flow_graph,
+    const ZoneGrowableArray<Definition*>& detached_defs) {
+  ASSERT(!flow_graph.is_licm_allowed());
+
+  Write<intptr_t>(flow_graph.current_ssa_temp_index());
+  Write<intptr_t>(flow_graph.max_block_id());
+  Write<intptr_t>(flow_graph.inlining_id());
+  Write<const Array&>(flow_graph.coverage_array());
+
+  PrologueInfo prologue_info = flow_graph.prologue_info();
+  Write<intptr_t>(prologue_info.min_block_id);
+  Write<intptr_t>(prologue_info.max_block_id);
+
+  // Write instructions
+  for (auto block : flow_graph.reverse_postorder()) {
+    Write<Instruction*>(block);
+    for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
+      Instruction* current = it.Current();
+      Write<Instruction*>(current);
+    }
+  }
+  Write<Instruction*>(nullptr);
+  Write<const ZoneGrowableArray<Definition*>&>(detached_defs);
+  can_write_refs_ = true;
+
+  // Write instructions extra info.
+  // It may contain references to other instructions.
+  for (auto block : flow_graph.reverse_postorder()) {
+    block->WriteExtra(this);
+    for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
+      Instruction* current = it.Current();
+      current->WriteExtra(this);
+    }
+  }
+  for (auto* instr : detached_defs) {
+    instr->WriteExtra(this);
+  }
+
+  const auto& optimized_block_order = flow_graph.optimized_block_order();
+  Write<intptr_t>(optimized_block_order.length());
+  for (intptr_t i = 0, n = optimized_block_order.length(); i < n; ++i) {
+    WriteRef<BlockEntryInstr*>(optimized_block_order[i]);
+  }
+
+  const auto* captured_parameters = flow_graph.captured_parameters();
+  if (captured_parameters->IsEmpty()) {
+    Write<bool>(false);
+  } else {
+    Write<bool>(true);
+    // Captured parameters are rare so write their bit numbers
+    // instead of writing BitVector.
+    GrowableArray<intptr_t> indices(Z, 0);
+    for (intptr_t i = 0, n = captured_parameters->length(); i < n; ++i) {
+      if (captured_parameters->Contains(i)) {
+        indices.Add(i);
+      }
+    }
+    Write<GrowableArray<intptr_t>>(indices);
+  }
+}
+
+FlowGraph* FlowGraphDeserializer::ReadFlowGraph() {
+  const intptr_t current_ssa_temp_index = Read<intptr_t>();
+  const intptr_t max_block_id = Read<intptr_t>();
+  const intptr_t inlining_id = Read<intptr_t>();
+  const Array& coverage_array = Read<const Array&>();
+  const PrologueInfo prologue_info(Read<intptr_t>(), Read<intptr_t>());
+
+  definitions_.EnsureLength(current_ssa_temp_index, nullptr);
+  blocks_.EnsureLength(max_block_id + 1, nullptr);
+
+  // Read/create instructions.
+  ZoneGrowableArray<Instruction*> instructions(16);
+  Instruction* prev = nullptr;
+  while (Instruction* instr = Read<Instruction*>()) {
+    instructions.Add(instr);
+    if (!instr->IsBlockEntry()) {
+      ASSERT(prev != nullptr);
+      prev->LinkTo(instr);
+    }
+    prev = instr;
+  }
+  ASSERT(graph_entry_ != nullptr);
+  const auto& detached_defs = Read<const ZoneGrowableArray<Definition*>&>();
+
+  // Read instructions extra info.
+  // It may contain references to other instructions.
+  for (Instruction* instr : instructions) {
+    instr->ReadExtra(this);
+  }
+  for (auto* instr : detached_defs) {
+    instr->ReadExtra(this);
+  }
+
+  FlowGraph* flow_graph = new (Z)
+      FlowGraph(parsed_function(), graph_entry_, max_block_id, prologue_info);
+  flow_graph->set_current_ssa_temp_index(current_ssa_temp_index);
+  flow_graph->CreateCommonConstants();
+  flow_graph->disallow_licm();
+  flow_graph->set_inlining_id(inlining_id);
+  flow_graph->set_coverage_array(coverage_array);
+
+  {
+    const intptr_t num_blocks = Read<intptr_t>();
+    if (num_blocks != 0) {
+      auto* codegen_block_order = flow_graph->CodegenBlockOrder(true);
+      ASSERT(codegen_block_order == &flow_graph->optimized_block_order());
+      for (intptr_t i = 0; i < num_blocks; ++i) {
+        codegen_block_order->Add(ReadRef<BlockEntryInstr*>());
+      }
+    }
+  }
+
+  if (Read<bool>()) {
+    GrowableArray<intptr_t> indices = Read<GrowableArray<intptr_t>>();
+    for (intptr_t i : indices) {
+      flow_graph->captured_parameters()->Add(i);
+    }
+  }
+
+  return flow_graph;
+}
+
+template <>
+void FlowGraphSerializer::Write<const Function&>(const Function& x) {
+  if (x.IsNull()) {
+    Write<int8_t>(-1);
+    return;
+  }
+  Write<int8_t>(x.kind());
+  switch (x.kind()) {
+    case UntaggedFunction::kRegularFunction:
+    case UntaggedFunction::kGetterFunction:
+    case UntaggedFunction::kSetterFunction:
+    case UntaggedFunction::kImplicitGetter:
+    case UntaggedFunction::kImplicitSetter:
+    case UntaggedFunction::kImplicitStaticGetter:
+    case UntaggedFunction::kConstructor: {
+      const auto& owner = Class::Handle(Z, x.Owner());
+      Write<classid_t>(owner.id());
+      const intptr_t function_index = owner.FindFunctionIndex(x);
+      ASSERT(function_index >= 0);
+      Write<intptr_t>(function_index);
+      return;
+    }
+    case UntaggedFunction::kImplicitClosureFunction: {
+      const auto& parent = Function::Handle(Z, x.parent_function());
+      Write<const Function&>(parent);
+      return;
+    }
+    case UntaggedFunction::kFieldInitializer: {
+      const auto& field = Field::Handle(Z, x.accessor_field());
+      Write<const Field&>(field);
+      return;
+    }
+    case UntaggedFunction::kClosureFunction:
+      // TODO(alexmarkov): we cannot rely on ClosureFunctionsCache
+      // as it is lazily populated when compiling functions.
+      // We need to serialize kernel offset and re-create
+      // closure functions when reading as needed.
+      Write<intptr_t>(ClosureFunctionsCache::FindClosureIndex(x));
+      return;
+    case UntaggedFunction::kMethodExtractor: {
+      Function& function = Function::Handle(Z, x.extracted_method_closure());
+      ASSERT(function.IsImplicitClosureFunction());
+      function = function.parent_function();
+      Write<const Function&>(function);
+      Write<const String&>(String::Handle(Z, x.name()));
+      return;
+    }
+    case UntaggedFunction::kInvokeFieldDispatcher: {
+      Write<const Class&>(Class::Handle(Z, x.Owner()));
+      Write<const String&>(String::Handle(Z, x.name()));
+      Write<const Array&>(Array::Handle(Z, x.saved_args_desc()));
+      return;
+    }
+    case UntaggedFunction::kDynamicInvocationForwarder: {
+      const auto& target = Function::Handle(Z, x.ForwardingTarget());
+      Write<const Function&>(target);
+      return;
+    }
+    case UntaggedFunction::kFfiTrampoline: {
+      if (x.FfiCallbackTarget() != Object::null()) {
+        UNIMPLEMENTED();
+      }
+      Write<const String&>(String::Handle(Z, x.name()));
+      Write<const FunctionType&>(FunctionType::Handle(Z, x.signature()));
+      Write<const FunctionType&>(FunctionType::Handle(Z, x.FfiCSignature()));
+      Write<bool>(x.FfiIsLeaf());
+      return;
+    }
+    default:
+      break;
+  }
+  switch (x.kind()) {
+#define UNIMPLEMENTED_FUNCTION_KIND(kind)                                      \
+  case UntaggedFunction::k##kind:                                              \
+    FATAL("Unimplemented Write<const Function&> for " #kind);
+    FOR_EACH_RAW_FUNCTION_KIND(UNIMPLEMENTED_FUNCTION_KIND)
+#undef UNIMPLEMENTED_FUNCTION_KIND
+  }
+  UNREACHABLE();
+}
+
+template <>
+const Function& FlowGraphDeserializer::Read<const Function&>() {
+  const int8_t raw_kind = Read<int8_t>();
+  if (raw_kind < 0) {
+    return Object::null_function();
+  }
+  const auto kind = static_cast<UntaggedFunction::Kind>(raw_kind);
+  switch (kind) {
+    case UntaggedFunction::kRegularFunction:
+    case UntaggedFunction::kGetterFunction:
+    case UntaggedFunction::kSetterFunction:
+    case UntaggedFunction::kImplicitGetter:
+    case UntaggedFunction::kImplicitSetter:
+    case UntaggedFunction::kImplicitStaticGetter:
+    case UntaggedFunction::kConstructor: {
+      const classid_t owner_class_id = Read<classid_t>();
+      const intptr_t function_index = Read<intptr_t>();
+      const auto& owner = Class::Handle(Z, GetClassById(owner_class_id));
+      const auto& result =
+          Function::ZoneHandle(Z, owner.FunctionFromIndex(function_index));
+      ASSERT(!result.IsNull());
+      return result;
+    }
+    case UntaggedFunction::kImplicitClosureFunction: {
+      const auto& parent = Read<const Function&>();
+      return Function::ZoneHandle(Z, parent.ImplicitClosureFunction());
+    }
+    case UntaggedFunction::kFieldInitializer: {
+      const auto& field = Read<const Field&>();
+      return Function::ZoneHandle(Z, field.EnsureInitializerFunction());
+    }
+    case UntaggedFunction::kClosureFunction: {
+      const intptr_t index = Read<intptr_t>();
+      return Function::ZoneHandle(
+          Z, ClosureFunctionsCache::ClosureFunctionFromIndex(index));
+    }
+    case UntaggedFunction::kMethodExtractor: {
+      const Function& function = Read<const Function&>();
+      const String& name = Read<const String&>();
+      return Function::ZoneHandle(Z, function.GetMethodExtractor(name));
+    }
+    case UntaggedFunction::kInvokeFieldDispatcher: {
+      const Class& owner = Read<const Class&>();
+      const String& target_name = Read<const String&>();
+      const Array& args_desc = Read<const Array&>();
+      return Function::ZoneHandle(
+          Z,
+          owner.GetInvocationDispatcher(
+              target_name, args_desc, UntaggedFunction::kInvokeFieldDispatcher,
+              /*create_if_absent=*/true));
+    }
+    case UntaggedFunction::kDynamicInvocationForwarder: {
+      const auto& target = Read<const Function&>();
+      auto& name = String::Handle(Z, target.name());
+      name = Function::CreateDynamicInvocationForwarderName(name);
+      return Function::ZoneHandle(Z,
+                                  target.GetDynamicInvocationForwarder(name));
+    }
+    case UntaggedFunction::kFfiTrampoline: {
+      const String& name = Read<const String&>();
+      const FunctionType& signature = Read<const FunctionType&>();
+      const FunctionType& c_signature = Read<const FunctionType&>();
+      const bool is_leaf = Read<bool>();
+      return Function::ZoneHandle(
+          Z, compiler::ffi::TrampolineFunction(name, signature, c_signature,
+                                               is_leaf));
+    }
+    default:
+      UNIMPLEMENTED();
+      return Object::null_function();
+  }
+}
+
+void FunctionEntryInstr::WriteTo(FlowGraphSerializer* s) {
+  BlockEntryWithInitialDefs::WriteTo(s);
+}
+
+FunctionEntryInstr::FunctionEntryInstr(FlowGraphDeserializer* d)
+    : BlockEntryWithInitialDefs(d), graph_entry_(d->graph_entry()) {}
+
+void GraphEntryInstr::WriteTo(FlowGraphSerializer* s) {
+  BlockEntryWithInitialDefs::WriteTo(s);
+  s->Write<intptr_t>(osr_id_);
+  s->Write<intptr_t>(entry_count_);
+  s->Write<intptr_t>(spill_slot_count_);
+  s->Write<intptr_t>(fixed_slot_count_);
+  s->Write<bool>(needs_frame_);
+}
+
+GraphEntryInstr::GraphEntryInstr(FlowGraphDeserializer* d)
+    : BlockEntryWithInitialDefs(d),
+      parsed_function_(d->parsed_function()),
+      osr_id_(d->Read<intptr_t>()),
+      entry_count_(d->Read<intptr_t>()),
+      spill_slot_count_(d->Read<intptr_t>()),
+      fixed_slot_count_(d->Read<intptr_t>()),
+      needs_frame_(d->Read<bool>()) {
+  d->set_graph_entry(this);
+}
+
+void GraphEntryInstr::WriteExtra(FlowGraphSerializer* s) {
+  BlockEntryWithInitialDefs::WriteExtra(s);
+  s->WriteRef<FunctionEntryInstr*>(normal_entry_);
+  s->WriteRef<FunctionEntryInstr*>(unchecked_entry_);
+  s->WriteRef<OsrEntryInstr*>(osr_entry_);
+  s->WriteGrowableArrayOfRefs<CatchBlockEntryInstr*>(catch_entries_);
+  s->WriteGrowableArrayOfRefs<IndirectEntryInstr*>(indirect_entries_);
+}
+
+void GraphEntryInstr::ReadExtra(FlowGraphDeserializer* d) {
+  BlockEntryWithInitialDefs::ReadExtra(d);
+  normal_entry_ = d->ReadRef<FunctionEntryInstr*>();
+  unchecked_entry_ = d->ReadRef<FunctionEntryInstr*>();
+  osr_entry_ = d->ReadRef<OsrEntryInstr*>();
+  catch_entries_ = d->ReadGrowableArrayOfRefs<CatchBlockEntryInstr*>();
+  indirect_entries_ = d->ReadGrowableArrayOfRefs<IndirectEntryInstr*>();
+}
+
+void GotoInstr::WriteExtra(FlowGraphSerializer* s) {
+  TemplateInstruction::WriteExtra(s);
+  if (parallel_move_ != nullptr) {
+    parallel_move_->WriteExtra(s);
+  }
+  s->WriteRef<JoinEntryInstr*>(successor_);
+}
+
+void GotoInstr::ReadExtra(FlowGraphDeserializer* d) {
+  TemplateInstruction::ReadExtra(d);
+  if (parallel_move_ != nullptr) {
+    parallel_move_->ReadExtra(d);
+  }
+  successor_ = d->ReadRef<JoinEntryInstr*>();
+}
+
+template <>
+void FlowGraphSerializer::Write<const ICData*>(const ICData* x) {
+  if (x == nullptr) {
+    Write<bool>(false);
+  } else {
+    Write<bool>(true);
+    ASSERT(!x->IsNull());
+    Write<const Object&>(*x);
+  }
+}
+
+template <>
+const ICData* FlowGraphDeserializer::Read<const ICData*>() {
+  if (!Read<bool>()) {
+    return nullptr;
+  }
+  return &ICData::Cast(Read<const Object&>());
+}
+
+void IfThenElseInstr::WriteExtra(FlowGraphSerializer* s) {
+  // IfThenElse reuses inputs from its embedded Comparison.
+  // Definition::WriteExtra is not called to avoid
+  // writing/reading inputs twice.
+  WriteExtraWithoutInputs(s);
+  comparison_->WriteExtra(s);
+}
+
+void IfThenElseInstr::ReadExtra(FlowGraphDeserializer* d) {
+  ReadExtraWithoutInputs(d);
+  comparison_->ReadExtra(d);
+  for (intptr_t i = comparison_->InputCount() - 1; i >= 0; --i) {
+    comparison_->InputAt(i)->set_instruction(this);
+  }
+}
+
+void IndirectGotoInstr::WriteTo(FlowGraphSerializer* s) {
+  TemplateInstruction::WriteTo(s);
+  s->Write<intptr_t>(offsets_.Length());
+}
+
+IndirectGotoInstr::IndirectGotoInstr(FlowGraphDeserializer* d)
+    : TemplateInstruction(d),
+      offsets_(TypedData::ZoneHandle(d->zone(),
+                                     TypedData::New(kTypedDataInt32ArrayCid,
+                                                    d->Read<intptr_t>(),
+                                                    Heap::kOld))) {}
+
+void IndirectGotoInstr::WriteExtra(FlowGraphSerializer* s) {
+  TemplateInstruction::WriteExtra(s);
+  s->WriteGrowableArrayOfRefs<TargetEntryInstr*>(successors_);
+}
+
+void IndirectGotoInstr::ReadExtra(FlowGraphDeserializer* d) {
+  TemplateInstruction::ReadExtra(d);
+  successors_ = d->ReadGrowableArrayOfRefs<TargetEntryInstr*>();
+}
+
+template <>
+void FlowGraphSerializer::Write<Instruction*>(Instruction* x) {
+  if (x == nullptr) {
+    Write<uint8_t>(Instruction::kNumInstructions);
+  } else {
+    Write<uint8_t>(static_cast<uint8_t>(x->tag()));
+    x->WriteTo(this);
+  }
+}
+
+template <>
+Instruction* FlowGraphDeserializer::Read<Instruction*>() {
+  const uint8_t tag = Read<uint8_t>();
+  switch (tag) {
+#define READ_INSTRUCTION(type, attrs)                                          \
+  case Instruction::k##type:                                                   \
+    return new (Z) type##Instr(this);
+    FOR_EACH_INSTRUCTION(READ_INSTRUCTION)
+#undef READ_INSTRUCTION
+    case Instruction::kNumInstructions:
+      return nullptr;
+  }
+  UNREACHABLE();
+  return nullptr;
+}
+
+void Instruction::WriteTo(FlowGraphSerializer* s) {
+  s->Write<intptr_t>(deopt_id_);
+  s->Write<intptr_t>(inlining_id_);
+}
+
+Instruction::Instruction(FlowGraphDeserializer* d)
+    : deopt_id_(d->Read<intptr_t>()), inlining_id_(d->Read<intptr_t>()) {}
+
+void Instruction::WriteExtra(FlowGraphSerializer* s) {
+  for (intptr_t i = 0, n = InputCount(); i < n; ++i) {
+    s->Write<Value*>(InputAt(i));
+  }
+  WriteExtraWithoutInputs(s);
+}
+
+void Instruction::ReadExtra(FlowGraphDeserializer* d) {
+  for (intptr_t i = 0, n = InputCount(); i < n; ++i) {
+    SetInputAt(i, d->Read<Value*>());
+  }
+  for (intptr_t i = InputCount() - 1; i >= 0; --i) {
+    Value* input = InputAt(i);
+    input->definition()->AddInputUse(input);
+  }
+  ReadExtraWithoutInputs(d);
+}
+
+void Instruction::WriteExtraWithoutInputs(FlowGraphSerializer* s) {
+  s->Write<Environment*>(env_);
+  s->Write<LocationSummary*>(locs_);
+}
+
+void Instruction::ReadExtraWithoutInputs(FlowGraphDeserializer* d) {
+  Environment* env = d->Read<Environment*>();
+  SetEnvironment(env);
+  locs_ = d->Read<LocationSummary*>();
+}
+
+#define INSTRUCTIONS_SERIALIZABLE_AS_INSTRUCTION(V)                            \
+  V(Comparison, ComparisonInstr)                                               \
+  V(Constant, ConstantInstr)                                                   \
+  V(Definition, Definition)                                                    \
+  V(ParallelMove, ParallelMoveInstr)                                           \
+  V(Phi, PhiInstr)
+
+#define SERIALIZABLE_AS_INSTRUCTION(name, type)                                \
+  template <>                                                                  \
+  void FlowGraphSerializer::Write<type*>(type * x) {                           \
+    Write<Instruction*>(x);                                                    \
+  }                                                                            \
+  template <>                                                                  \
+  type* FlowGraphDeserializer::Read<type*>() {                                 \
+    Instruction* instr = Read<Instruction*>();                                 \
+    ASSERT((instr == nullptr) || instr->Is##name());                           \
+    return static_cast<type*>(instr);                                          \
+  }
+
+INSTRUCTIONS_SERIALIZABLE_AS_INSTRUCTION(SERIALIZABLE_AS_INSTRUCTION)
+#undef SERIALIZABLE_AS_INSTRUCTION
+#undef INSTRUCTIONS_SERIALIZABLE_AS_INSTRUCTION
+
+template <>
+void FlowGraphSerializer::Write<int8_t>(int8_t x) {
+  stream_->Write<int8_t>(x);
+}
+
+template <>
+int8_t FlowGraphDeserializer::Read<int8_t>() {
+  return stream_->Read<int8_t>();
+}
+
+template <>
+void FlowGraphSerializer::Write<int16_t>(int16_t x) {
+  stream_->Write<int16_t>(x);
+}
+
+template <>
+int16_t FlowGraphDeserializer::Read<int16_t>() {
+  return stream_->Read<int16_t>();
+}
+
+template <>
+void FlowGraphSerializer::Write<int32_t>(int32_t x) {
+  stream_->Write<int32_t>(x);
+}
+
+template <>
+int32_t FlowGraphDeserializer::Read<int32_t>() {
+  return stream_->Read<int32_t>();
+}
+
+template <>
+void FlowGraphSerializer::Write<int64_t>(int64_t x) {
+  stream_->Write<int64_t>(x);
+}
+
+template <>
+int64_t FlowGraphDeserializer::Read<int64_t>() {
+  return stream_->Read<int64_t>();
+}
+
+void JoinEntryInstr::WriteExtra(FlowGraphSerializer* s) {
+  BlockEntryInstr::WriteExtra(s);
+  if (phis_ != nullptr) {
+    for (PhiInstr* phi : *phis_) {
+      phi->WriteExtra(s);
+    }
+  }
+}
+
+void JoinEntryInstr::ReadExtra(FlowGraphDeserializer* d) {
+  BlockEntryInstr::ReadExtra(d);
+  if (phis_ != nullptr) {
+    for (PhiInstr* phi : *phis_) {
+      phi->ReadExtra(d);
+    }
+  }
+}
+
+template <>
+void FlowGraphSerializer::Write<const LocalVariable&>(const LocalVariable& x) {
+  UNIMPLEMENTED();
+}
+
+template <>
+const LocalVariable& FlowGraphDeserializer::Read<const LocalVariable&>() {
+  UNIMPLEMENTED();
+  return *parsed_function().receiver_var();
+}
+
+void Location::Write(FlowGraphSerializer* s) const {
+  if (IsPairLocation()) {
+    s->Write<uword>(value_ & kLocationTagMask);
+    PairLocation* pair = AsPairLocation();
+    pair->At(0).Write(s);
+    pair->At(1).Write(s);
+  } else if (IsConstant()) {
+    s->Write<uword>(value_ & kLocationTagMask);
+    s->WriteRef<Definition*>(constant_instruction());
+  } else {
+    s->Write<uword>(value_);
+  }
+}
+
+Location Location::Read(FlowGraphDeserializer* d) {
+  const uword value = d->Read<uword>();
+  if (value == kPairLocationTag) {
+    return Location::Pair(Location::Read(d), Location::Read(d));
+  } else if ((value & kConstantTag) == kConstantTag) {
+    ConstantInstr* instr = d->ReadRef<Definition*>()->AsConstant();
+    ASSERT(instr != nullptr);
+    const int pair_index = (value & kPairLocationTag) != 0 ? 1 : 0;
+    return Location::Constant(instr, pair_index);
+  } else {
+    return Location(value);
+  }
+}
+
+template <>
+void FlowGraphSerializer::Write<LocationSummary*>(LocationSummary* x) {
+  ASSERT(can_write_refs());
+  if (x == nullptr) {
+    Write<bool>(false);
+  } else {
+    Write<bool>(true);
+    x->Write(this);
+  }
+}
+
+template <>
+LocationSummary* FlowGraphDeserializer::Read<LocationSummary*>() {
+  if (!Read<bool>()) {
+    return nullptr;
+  }
+  return new (Z) LocationSummary(this);
+}
+
+void LocationSummary::Write(FlowGraphSerializer* s) const {
+  s->Write<intptr_t>(input_count());
+  s->Write<intptr_t>(temp_count());
+  s->Write<int8_t>(static_cast<int8_t>(contains_call_));
+  live_registers_.Write(s);
+
+  for (intptr_t i = 0, n = input_count(); i < n; ++i) {
+    in(i).Write(s);
+  }
+  for (intptr_t i = 0, n = temp_count(); i < n; ++i) {
+    temp(i).Write(s);
+  }
+  ASSERT(output_count() == 1);
+  out(0).Write(s);
+
+  if ((stack_bitmap_ != nullptr) && (stack_bitmap_->Length() != 0)) {
+    s->Write<int8_t>(1);
+    stack_bitmap_->Write(s->stream());
+  } else {
+    s->Write<int8_t>(0);
+  }
+
+#if defined(DEBUG)
+  s->Write<intptr_t>(writable_inputs_);
+#endif
+}
+
+LocationSummary::LocationSummary(FlowGraphDeserializer* d)
+    : num_inputs_(d->Read<intptr_t>()),
+      num_temps_(d->Read<intptr_t>()),
+      output_location_(),
+      stack_bitmap_(nullptr),
+      contains_call_(static_cast<ContainsCall>(d->Read<int8_t>())),
+      live_registers_(d) {
+  input_locations_ = d->zone()->Alloc<Location>(num_inputs_);
+  for (intptr_t i = 0; i < num_inputs_; ++i) {
+    input_locations_[i] = Location::Read(d);
+  }
+  temp_locations_ = d->zone()->Alloc<Location>(num_temps_);
+  for (intptr_t i = 0; i < num_temps_; ++i) {
+    temp_locations_[i] = Location::Read(d);
+  }
+  output_location_ = Location::Read(d);
+
+  if (d->Read<int8_t>() != 0) {
+    EnsureStackBitmap().Read(d->stream());
+  }
+
+#if defined(DEBUG)
+  writable_inputs_ = d->Read<intptr_t>();
+#endif
+}
+
+void MakeTempInstr::WriteExtra(FlowGraphSerializer* s) {
+  TemplateDefinition::WriteExtra(s);
+  null_->WriteExtra(s);
+}
+
+void MakeTempInstr::ReadExtra(FlowGraphDeserializer* d) {
+  TemplateDefinition::ReadExtra(d);
+  null_->ReadExtra(d);
+}
+
+void MaterializeObjectInstr::WriteExtra(FlowGraphSerializer* s) {
+  VariadicDefinition::WriteExtra(s);
+  for (intptr_t i = 0, n = InputCount(); i < n; ++i) {
+    locations_[i].Write(s);
+  }
+}
+
+void MaterializeObjectInstr::ReadExtra(FlowGraphDeserializer* d) {
+  VariadicDefinition::ReadExtra(d);
+  locations_ = d->zone()->Alloc<Location>(InputCount());
+  for (intptr_t i = 0, n = InputCount(); i < n; ++i) {
+    locations_[i] = Location::Read(d);
+  }
+}
+
+template <>
+void FlowGraphSerializer::Write<MoveOperands*>(MoveOperands* x) {
+  ASSERT(x != nullptr);
+  x->src().Write(this);
+  x->dest().Write(this);
+}
+
+template <>
+MoveOperands* FlowGraphDeserializer::Read<MoveOperands*>() {
+  Location src = Location::Read(this);
+  Location dest = Location::Read(this);
+  return new (Z) MoveOperands(dest, src);
+}
+
+template <>
+void FlowGraphSerializer::Write<const compiler::ffi::NativeCallingConvention&>(
+    const compiler::ffi::NativeCallingConvention& x) {
+  // A subset of NativeCallingConvention currently used by CCallInstr.
+  const auto& args = x.argument_locations();
+  for (intptr_t i = 0, n = args.length(); i < n; ++i) {
+    if (args.At(i)->payload_type().AsRepresentation() != kUnboxedFfiIntPtr) {
+      UNIMPLEMENTED();
+    }
+  }
+  if (x.return_location().payload_type().AsRepresentation() !=
+      kUnboxedFfiIntPtr) {
+    UNIMPLEMENTED();
+  }
+  Write<intptr_t>(args.length());
+}
+
+template <>
+const compiler::ffi::NativeCallingConvention&
+FlowGraphDeserializer::Read<const compiler::ffi::NativeCallingConvention&>() {
+  const intptr_t num_args = Read<intptr_t>();
+  const auto& native_function_type =
+      *compiler::ffi::NativeFunctionType::FromUnboxedRepresentation(
+          Z, num_args, kUnboxedFfiIntPtr);
+  return compiler::ffi::NativeCallingConvention::FromSignature(
+      Z, native_function_type);
+}
+
+template <>
+void FlowGraphSerializer::Write<const Object&>(const Object& x) {
+  const intptr_t cid = x.GetClassId();
+  ASSERT(cid != kIllegalCid);
+  // Do not write objects repeatedly.
+  const intptr_t object_id = heap_->GetObjectId(x.ptr());
+  if (object_id != 0) {
+    const intptr_t object_index = object_id - 1;
+    Write<intptr_t>(kIllegalCid);
+    Write<intptr_t>(object_index);
+    return;
+  }
+  const intptr_t object_index = object_counter_++;
+  heap_->SetObjectId(x.ptr(), object_index + 1);
+  Write<intptr_t>(cid);
+  WriteObjectImpl(x, cid, object_index);
+}
+
+template <>
+const Object& FlowGraphDeserializer::Read<const Object&>() {
+  const intptr_t cid = Read<intptr_t>();
+  if (cid == kIllegalCid) {
+    const intptr_t object_index = Read<intptr_t>();
+    return *objects_[object_index];
+  }
+  const intptr_t object_index = object_counter_;
+  object_counter_++;
+  const Object& result = ReadObjectImpl(cid, object_index);
+  SetObjectAt(object_index, result);
+  return result;
+}
+
+void FlowGraphDeserializer::SetObjectAt(intptr_t object_index,
+                                        const Object& object) {
+  objects_.EnsureLength(object_index + 1, &Object::null_object());
+  objects_[object_index] = &object;
+}
+
+void FlowGraphSerializer::WriteObjectImpl(const Object& x,
+                                          intptr_t cid,
+                                          intptr_t object_index) {
+  switch (cid) {
+    case kArrayCid:
+    case kImmutableArrayCid: {
+      const auto& array = Array::Cast(x);
+      const intptr_t len = array.Length();
+      Write<intptr_t>(len);
+      const auto& type_args =
+          TypeArguments::Handle(Z, array.GetTypeArguments());
+      Write<const TypeArguments&>(type_args);
+      if ((len == 0) && type_args.IsNull()) {
+        break;
+      }
+      Write<bool>(array.IsCanonical());
+      auto& elem = Object::Handle(Z);
+      for (intptr_t i = 0; i < len; ++i) {
+        elem = array.At(i);
+        Write<const Object&>(elem);
+      }
+      break;
+    }
+    case kBoolCid:
+      Write<bool>(Bool::Cast(x).value());
+      break;
+    case kClosureCid: {
+      const auto& closure = Closure::Cast(x);
+      if (closure.context() != Object::null()) {
+        UNIMPLEMENTED();
+      }
+      ASSERT(closure.IsCanonical());
+      auto& type_args = TypeArguments::Handle(Z);
+      type_args = closure.instantiator_type_arguments();
+      Write<const TypeArguments&>(type_args);
+      type_args = closure.function_type_arguments();
+      Write<const TypeArguments&>(type_args);
+      type_args = closure.delayed_type_arguments();
+      Write<const TypeArguments&>(type_args);
+      Write<const Function&>(Function::Handle(Z, closure.function()));
+      break;
+    }
+    case kDoubleCid:
+      ASSERT(x.IsCanonical());
+      Write<double>(Double::Cast(x).value());
+      break;
+    case kFieldCid: {
+      const auto& field = Field::Cast(x);
+      const auto& owner = Class::Handle(Z, field.Owner());
+      Write<classid_t>(owner.id());
+      const intptr_t field_index = owner.FindFieldIndex(field);
+      ASSERT(field_index >= 0);
+      Write<intptr_t>(field_index);
+      break;
+    }
+    case kFunctionCid:
+      Write<const Function&>(Function::Cast(x));
+      break;
+    case kFunctionTypeCid: {
+      const auto& type = FunctionType::Cast(x);
+      ASSERT(type.IsFinalized());
+      TypeScope type_scope(this, type.IsRecursive());
+      Write<int8_t>(static_cast<int8_t>(type.nullability()));
+      Write<uint32_t>(type.packed_parameter_counts());
+      Write<uint16_t>(type.packed_type_parameter_counts());
+      Write<const TypeParameters&>(
+          TypeParameters::Handle(Z, type.type_parameters()));
+      AbstractType& t = AbstractType::Handle(Z, type.result_type());
+      Write<const AbstractType&>(t);
+      // Do not write parameter types as Array to avoid eager canonicalization
+      // when reading.
+      const Array& param_types = Array::Handle(Z, type.parameter_types());
+      ASSERT(param_types.Length() == type.NumParameters());
+      for (intptr_t i = 0, n = type.NumParameters(); i < n; ++i) {
+        t ^= param_types.At(i);
+        Write<const AbstractType&>(t);
+      }
+      Write<const Array&>(Array::Handle(Z, type.named_parameter_names()));
+      Write<bool>(type_scope.CanBeCanonicalized());
+      break;
+    }
+    case kICDataCid: {
+      const auto& icdata = ICData::Cast(x);
+      Write<int8_t>(static_cast<int8_t>(icdata.rebind_rule()));
+      Write<const Function&>(Function::Handle(Z, icdata.Owner()));
+      Write<const Array&>(Array::Handle(Z, icdata.arguments_descriptor()));
+      Write<intptr_t>(icdata.deopt_id());
+      Write<intptr_t>(icdata.NumArgsTested());
+      if (icdata.rebind_rule() == ICData::kStatic) {
+        ASSERT(icdata.NumberOfChecks() == 1);
+        Write<const Function&>(Function::Handle(Z, icdata.GetTargetAt(0)));
+      } else if (icdata.rebind_rule() == ICData::kInstance) {
+        if (icdata.NumberOfChecks() != 0) {
+          UNIMPLEMENTED();
+        }
+        Write<const String&>(String::Handle(Z, icdata.target_name()));
+      } else {
+        UNIMPLEMENTED();
+      }
+      break;
+    }
+    case kImmutableLinkedHashMapCid:
+    case kImmutableLinkedHashSetCid: {
+      const auto& map = LinkedHashBase::Cast(x);
+      ASSERT(map.IsCanonical());
+      const intptr_t length = map.Length();
+      Write<intptr_t>(length);
+      Write<const TypeArguments&>(
+          TypeArguments::Handle(Z, map.GetTypeArguments()));
+      const auto& data = Array::Handle(Z, map.data());
+      auto& elem = Object::Handle(Z);
+      intptr_t used_data;
+      if (cid == kImmutableLinkedHashMapCid) {
+        used_data = length << 1;
+      } else {
+        used_data = length;
+      }
+      for (intptr_t i = 0; i < used_data; ++i) {
+        elem = data.At(i);
+        Write<const Object&>(elem);
+      }
+      break;
+    }
+    case kLibraryPrefixCid: {
+      const auto& prefix = LibraryPrefix::Cast(x);
+      const Library& library = Library::Handle(Z, prefix.importer());
+      Write<classid_t>(Class::Handle(Z, library.toplevel_class()).id());
+      Write<const String&>(String::Handle(Z, prefix.name()));
+      break;
+    }
+    case kMintCid:
+      ASSERT(x.IsCanonical());
+      Write<int64_t>(Integer::Cast(x).AsInt64Value());
+      break;
+    case kNullCid:
+      break;
+    case kOneByteStringCid: {
+      ASSERT(x.IsCanonical());
+      const auto& str = String::Cast(x);
+      const intptr_t length = str.Length();
+      Write<intptr_t>(length);
+      NoSafepointScope no_safepoint;
+      uint8_t* latin1 = OneByteString::DataStart(str);
+      stream_->WriteBytes(latin1, length);
+      break;
+    }
+    case kSentinelCid:
+      if (x.ptr() == Object::sentinel().ptr()) {
+        Write<bool>(true);
+      } else if (x.ptr() == Object::transition_sentinel().ptr()) {
+        Write<bool>(false);
+      } else {
+        UNIMPLEMENTED();
+      }
+      break;
+    case kSmiCid:
+      Write<intptr_t>(Smi::Cast(x).Value());
+      break;
+    case kTwoByteStringCid: {
+      ASSERT(x.IsCanonical());
+      const auto& str = String::Cast(x);
+      const intptr_t length = str.Length();
+      Write<intptr_t>(length);
+      NoSafepointScope no_safepoint;
+      uint16_t* utf16 = TwoByteString::DataStart(str);
+      stream_->WriteBytes(reinterpret_cast<const uint8_t*>(utf16),
+                          length * sizeof(uint16_t));
+      break;
+    }
+    case kTypeCid: {
+      const auto& type = Type::Cast(x);
+      ASSERT(type.IsFinalized());
+      const auto& cls = Class::Handle(Z, type.type_class());
+      TypeScope type_scope(this, type.IsRecursive() && cls.IsGeneric());
+      Write<int8_t>(static_cast<int8_t>(type.nullability()));
+      Write<classid_t>(type.type_class_id());
+      if (cls.IsGeneric()) {
+        const auto& type_args = TypeArguments::Handle(Z, type.arguments());
+        Write<const TypeArguments&>(type_args);
+      }
+      Write<bool>(type_scope.CanBeCanonicalized());
+      break;
+    }
+    case kTypeArgumentsCid: {
+      const auto& type_args = TypeArguments::Cast(x);
+      ASSERT(type_args.IsFinalized());
+      TypeScope type_scope(this, type_args.IsRecursive());
+      const intptr_t len = type_args.Length();
+      Write<intptr_t>(len);
+      auto& type = AbstractType::Handle(Z);
+      for (intptr_t i = 0; i < len; ++i) {
+        type = type_args.TypeAt(i);
+        Write<const AbstractType&>(type);
+      }
+      Write<bool>(type_scope.CanBeCanonicalized());
+      break;
+    }
+    case kTypeParameterCid: {
+      const auto& tp = TypeParameter::Cast(x);
+      ASSERT(tp.IsFinalized());
+      TypeScope type_scope(this, tp.IsRecursive());
+      Write<classid_t>(tp.parameterized_class_id());
+      Write<intptr_t>(tp.base());
+      Write<intptr_t>(tp.index());
+      Write<int8_t>(static_cast<int8_t>(tp.nullability()));
+      Write<const AbstractType&>(AbstractType::Handle(Z, tp.bound()));
+      Write<bool>(type_scope.CanBeCanonicalized());
+      break;
+    }
+    case kTypeParametersCid: {
+      const auto& tps = TypeParameters::Cast(x);
+      Write<const Array&>(Array::Handle(Z, tps.names()));
+      Write<const Array&>(Array::Handle(Z, tps.flags()));
+      Write<const TypeArguments&>(TypeArguments::Handle(Z, tps.bounds()));
+      Write<const TypeArguments&>(TypeArguments::Handle(Z, tps.defaults()));
+      break;
+    }
+    case kTypeRefCid: {
+      const auto& tr = TypeRef::Cast(x);
+      ASSERT(tr.IsFinalized());
+      TypeScope type_scope(this, tr.IsRecursive());
+      Write<const AbstractType&>(AbstractType::Handle(Z, tr.type()));
+      Write<bool>(type_scope.CanBeCanonicalized());
+      break;
+    }
+    default: {
+      const classid_t cid = x.GetClassId();
+      if ((cid >= kNumPredefinedCids) || (cid == kInstanceCid)) {
+        const auto& instance = Instance::Cast(x);
+        ASSERT(instance.IsCanonical());
+        const auto& cls =
+            Class::Handle(Z, isolate_group()->class_table()->At(cid));
+        const auto unboxed_fields_bitmap =
+            isolate_group()->shared_class_table()->GetUnboxedFieldsMapAt(cid);
+        const intptr_t next_field_offset = cls.host_next_field_offset();
+        auto& obj = Object::Handle(Z);
+        for (intptr_t offset = Instance::NextFieldOffset();
+             offset < next_field_offset; offset += kCompressedWordSize) {
+          if (unboxed_fields_bitmap.Get(offset / kCompressedWordSize)) {
+            if (kCompressedWordSize == 8) {
+              Write<int64_t>(*reinterpret_cast<int64_t*>(
+                  instance.RawFieldAddrAtOffset(offset)));
+            } else {
+              Write<int32_t>(*reinterpret_cast<int32_t*>(
+                  instance.RawFieldAddrAtOffset(offset)));
+            }
+          } else {
+            obj = instance.RawGetFieldAtOffset(offset);
+            Write<const Object&>(obj);
+          }
+        }
+        break;
+      }
+      FATAL("Unimplemented WriteObjectImpl for %s", x.ToCString());
+    }
+  }
+}
+
+const Object& FlowGraphDeserializer::ReadObjectImpl(intptr_t cid,
+                                                    intptr_t object_index) {
+  switch (cid) {
+    case kArrayCid:
+    case kImmutableArrayCid: {
+      const intptr_t len = Read<intptr_t>();
+      const auto& type_args = Read<const TypeArguments&>();
+      if ((len == 0) && type_args.IsNull()) {
+        return Object::empty_array();
+      }
+      const bool canonicalize = Read<bool>();
+      auto& array = Array::ZoneHandle(
+          Z, Array::New(len, canonicalize ? Heap::kNew : Heap::kOld));
+      if (!type_args.IsNull()) {
+        array.SetTypeArguments(type_args);
+      }
+      for (intptr_t i = 0; i < len; ++i) {
+        array.SetAt(i, Read<const Object&>());
+      }
+      if (cid == kImmutableArrayCid) {
+        array.MakeImmutable();
+      }
+      if (canonicalize) {
+        array ^= array.Canonicalize(thread());
+      }
+      return array;
+    }
+    case kBoolCid:
+      return Bool::Get(Read<bool>());
+    case kClosureCid: {
+      const auto& instantiator_type_arguments = Read<const TypeArguments&>();
+      const auto& function_type_arguments = Read<const TypeArguments&>();
+      const auto& delayed_type_arguments = Read<const TypeArguments&>();
+      const auto& function = Read<const Function&>();
+      auto& closure = Closure::ZoneHandle(
+          Z,
+          Closure::New(instantiator_type_arguments, function_type_arguments,
+                       delayed_type_arguments, function, Context::Handle(Z)));
+      closure ^= closure.Canonicalize(thread());
+      return closure;
+    }
+    case kDoubleCid:
+      return Double::ZoneHandle(Z, Double::NewCanonical(Read<double>()));
+    case kFieldCid: {
+      const classid_t owner_class_id = Read<classid_t>();
+      const intptr_t field_index = Read<intptr_t>();
+      const auto& owner = Class::Handle(Z, GetClassById(owner_class_id));
+      auto& result = Field::ZoneHandle(Z, owner.FieldFromIndex(field_index));
+      ASSERT(!result.IsNull());
+      return result;
+    }
+    case kFunctionCid:
+      return Read<const Function&>();
+    case kFunctionTypeCid: {
+      const Nullability nullability = static_cast<Nullability>(Read<int8_t>());
+      auto& result =
+          FunctionType::ZoneHandle(Z, FunctionType::New(0, nullability));
+      SetObjectAt(object_index, result);
+      result.set_packed_parameter_counts(Read<uint32_t>());
+      result.set_packed_type_parameter_counts(Read<uint16_t>());
+      result.SetTypeParameters(Read<const TypeParameters&>());
+      result.set_result_type(Read<const AbstractType&>());
+      const Array& param_types =
+          Array::Handle(Z, Array::New(result.NumParameters(), Heap::kOld));
+      for (intptr_t i = 0, n = result.NumParameters(); i < n; ++i) {
+        param_types.SetAt(i, Read<const AbstractType&>());
+      }
+      result.set_parameter_types(param_types);
+      result.set_named_parameter_names(Read<const Array&>());
+      result.SetIsFinalized();
+      result ^= MaybeCanonicalize(result, object_index, Read<bool>());
+      return result;
+    }
+    case kICDataCid: {
+      const ICData::RebindRule rebind_rule =
+          static_cast<ICData::RebindRule>(Read<int8_t>());
+      const auto& owner = Read<const Function&>();
+      const auto& arguments_descriptor = Read<const Array&>();
+      const intptr_t deopt_id = Read<intptr_t>();
+      const intptr_t num_args_tested = Read<intptr_t>();
+
+      if (rebind_rule == ICData::kStatic) {
+        const auto& target = Read<const Function&>();
+        return ICData::ZoneHandle(
+            Z,
+            ICData::NewForStaticCall(owner, target, arguments_descriptor,
+                                     deopt_id, num_args_tested, rebind_rule));
+      } else if (rebind_rule == ICData::kInstance) {
+        const auto& target_name = Read<const String&>();
+        return ICData::ZoneHandle(
+            Z, ICData::New(owner, target_name, arguments_descriptor, deopt_id,
+                           num_args_tested, rebind_rule));
+      } else {
+        UNIMPLEMENTED();
+      }
+      break;
+    }
+    case kImmutableLinkedHashMapCid:
+    case kImmutableLinkedHashSetCid: {
+      const intptr_t length = Read<intptr_t>();
+      const auto& type_args = Read<const TypeArguments&>();
+      Instance& result = Instance::ZoneHandle(Z);
+      intptr_t used_data;
+      if (cid == kImmutableLinkedHashMapCid) {
+        result = ImmutableLinkedHashMap::NewUninitialized(Heap::kOld);
+        used_data = (length << 1);
+      } else {
+        result = ImmutableLinkedHashSet::NewUninitialized(Heap::kOld);
+        used_data = length;
+      }
+      // LinkedHashBase is not a proper handle type, so
+      // cannot create a LinkedHashBase handle upfront.
+      const LinkedHashBase& map = LinkedHashBase::Cast(result);
+      map.SetTypeArguments(type_args);
+      map.set_used_data(used_data);
+      const auto& data = Array::Handle(Z, Array::New(used_data));
+      map.set_data(data);
+      map.set_deleted_keys(0);
+      map.ComputeAndSetHashMask();
+      for (intptr_t i = 0; i < used_data; ++i) {
+        data.SetAt(i, Read<const Object&>());
+      }
+      result ^= result.Canonicalize(thread());
+      return result;
+    }
+    case kLibraryPrefixCid: {
+      const Class& toplevel_class =
+          Class::Handle(Z, GetClassById(Read<classid_t>()));
+      const Library& library = Library::Handle(Z, toplevel_class.library());
+      const String& name = Read<const String&>();
+      const auto& prefix =
+          LibraryPrefix::ZoneHandle(Z, library.LookupLocalLibraryPrefix(name));
+      ASSERT(!prefix.IsNull());
+      return prefix;
+    }
+    case kMintCid: {
+      const int64_t value = Read<int64_t>();
+      return Integer::ZoneHandle(Z, Integer::NewCanonical(value));
+    }
+    case kNullCid:
+      return Object::null_object();
+    case kOneByteStringCid: {
+      const intptr_t length = Read<intptr_t>();
+      uint8_t* latin1 = Z->Alloc<uint8_t>(length);
+      stream_->ReadBytes(latin1, length);
+      return String::ZoneHandle(Z,
+                                Symbols::FromLatin1(thread(), latin1, length));
+    }
+    case kSentinelCid:
+      return Read<bool>() ? Object::sentinel() : Object::transition_sentinel();
+    case kSmiCid:
+      return Smi::ZoneHandle(Z, Smi::New(Read<intptr_t>()));
+    case kTwoByteStringCid: {
+      const intptr_t length = Read<intptr_t>();
+      uint16_t* utf16 = Z->Alloc<uint16_t>(length);
+      stream_->ReadBytes(reinterpret_cast<uint8_t*>(utf16),
+                         length * sizeof(uint16_t));
+      return String::ZoneHandle(Z, Symbols::FromUTF16(thread(), utf16, length));
+    }
+    case kTypeCid: {
+      const Nullability nullability = static_cast<Nullability>(Read<int8_t>());
+      const classid_t type_class_id = Read<classid_t>();
+      const auto& cls = Class::Handle(Z, GetClassById(type_class_id));
+      auto& result = Type::ZoneHandle(Z);
+      if (cls.IsGeneric()) {
+        result = Type::New(cls, Object::null_type_arguments(), nullability);
+        SetObjectAt(object_index, result);
+        const auto& type_args = Read<const TypeArguments&>();
+        result.set_arguments(type_args);
+        result.SetIsFinalized();
+      } else {
+        result = cls.DeclarationType();
+        result = result.ToNullability(nullability, Heap::kOld);
+      }
+      result ^= MaybeCanonicalize(result, object_index, Read<bool>());
+      return result;
+    }
+    case kTypeArgumentsCid: {
+      const intptr_t len = Read<intptr_t>();
+      auto& type_args = TypeArguments::ZoneHandle(Z, TypeArguments::New(len));
+      SetObjectAt(object_index, type_args);
+      for (intptr_t i = 0; i < len; ++i) {
+        type_args.SetTypeAt(i, Read<const AbstractType&>());
+      }
+      type_args ^= MaybeCanonicalize(type_args, object_index, Read<bool>());
+      return type_args;
+    }
+    case kTypeParameterCid: {
+      const classid_t parameterized_class_id = Read<classid_t>();
+      const intptr_t base = Read<intptr_t>();
+      const intptr_t index = Read<intptr_t>();
+      const Nullability nullability = static_cast<Nullability>(Read<int8_t>());
+      const auto& parameterized_class =
+          Class::Handle(Z, (parameterized_class_id == kFunctionCid)
+                               ? Class::null()
+                               : GetClassById(parameterized_class_id));
+      auto& tp = TypeParameter::ZoneHandle(
+          Z, TypeParameter::New(parameterized_class, base, index,
+                                /*bound=*/Object::null_abstract_type(),
+                                nullability));
+      SetObjectAt(object_index, tp);
+      const auto& bound = Read<const AbstractType&>();
+      tp.set_bound(bound);
+      tp.SetIsFinalized();
+      tp ^= MaybeCanonicalize(tp, object_index, Read<bool>());
+      return tp;
+    }
+    case kTypeParametersCid: {
+      const auto& tps = TypeParameters::ZoneHandle(Z, TypeParameters::New());
+      tps.set_names(Read<const Array&>());
+      tps.set_flags(Read<const Array&>());
+      tps.set_bounds(Read<const TypeArguments&>());
+      tps.set_defaults(Read<const TypeArguments&>());
+      return tps;
+    }
+    case kTypeRefCid: {
+      auto& tr =
+          TypeRef::ZoneHandle(Z, TypeRef::New(Object::null_abstract_type()));
+      SetObjectAt(object_index, tr);
+      const auto& type = Read<const AbstractType&>();
+      ASSERT(!type.IsNull());
+      tr.set_type(type);
+      tr ^= MaybeCanonicalize(tr, object_index, Read<bool>());
+      return tr;
+    }
+    default:
+      if ((cid >= kNumPredefinedCids) || (cid == kInstanceCid)) {
+        const auto& cls = Class::Handle(Z, GetClassById(cid));
+        const auto unboxed_fields_bitmap =
+            isolate_group()->shared_class_table()->GetUnboxedFieldsMapAt(cid);
+        const intptr_t next_field_offset = cls.host_next_field_offset();
+        auto& instance = Instance::ZoneHandle(Z, Instance::New(cls));
+        for (intptr_t offset = Instance::NextFieldOffset();
+             offset < next_field_offset; offset += kCompressedWordSize) {
+          if (unboxed_fields_bitmap.Get(offset / kCompressedWordSize)) {
+            if (kCompressedWordSize == 8) {
+              const int64_t v = Read<int64_t>();
+              *reinterpret_cast<int64_t*>(
+                  instance.RawFieldAddrAtOffset(offset)) = v;
+            } else {
+              const int32_t v = Read<int32_t>();
+              *reinterpret_cast<int32_t*>(
+                  instance.RawFieldAddrAtOffset(offset)) = v;
+            }
+          } else {
+            const auto& obj = Read<const Object&>();
+            instance.RawSetFieldAtOffset(offset, obj);
+          }
+        }
+        instance = instance.Canonicalize(thread());
+        return instance;
+      }
+  }
+  UNIMPLEMENTED();
+  return Object::null_object();
+}
+
+InstancePtr FlowGraphDeserializer::MaybeCanonicalize(
+    const Instance& obj,
+    intptr_t object_index,
+    bool can_be_canonicalized) {
+  if (can_be_canonicalized) {
+    intptr_t remaining = 0;
+    for (intptr_t idx : pending_canonicalization_) {
+      if (idx < object_index) {
+        pending_canonicalization_[remaining++] = idx;
+      } else {
+        objects_[idx] = &Instance::ZoneHandle(
+            Z, Instance::Cast(*objects_[idx]).Canonicalize(thread()));
+      }
+    }
+    pending_canonicalization_.TruncateTo(remaining);
+    return obj.Canonicalize(thread());
+  } else {
+    ASSERT(objects_[object_index]->ptr() == obj.ptr());
+    pending_canonicalization_.Add(object_index);
+    return obj.ptr();
+  }
+}
+
+#define HANDLES_SERIALIZABLE_AS_OBJECT(V)                                      \
+  V(AbstractType, Object::null_abstract_type())                                \
+  V(Array, Object::null_array())                                               \
+  V(Field, Field::Handle(Z))                                                   \
+  V(FunctionType, Object::null_function_type())                                \
+  V(String, Object::null_string())                                             \
+  V(TypeArguments, Object::null_type_arguments())                              \
+  V(TypeParameters, TypeParameters::Handle(Z))
+
+#define SERIALIZE_HANDLE_AS_OBJECT(handle, null_handle)                        \
+  template <>                                                                  \
+  void FlowGraphSerializer::Write<const handle&>(const handle& x) {            \
+    Write<const Object&>(x);                                                   \
+  }                                                                            \
+  template <>                                                                  \
+  const handle& FlowGraphDeserializer::Read<const handle&>() {                 \
+    const Object& result = Read<const Object&>();                              \
+    if (result.IsNull()) {                                                     \
+      return null_handle;                                                      \
+    }                                                                          \
+    return handle::Cast(result);                                               \
+  }
+
+HANDLES_SERIALIZABLE_AS_OBJECT(SERIALIZE_HANDLE_AS_OBJECT)
+#undef SERIALIZE_HANDLE_AS_OBJECT
+#undef HANDLES_SERIALIZABLE_AS_OBJECT
+
+void OsrEntryInstr::WriteTo(FlowGraphSerializer* s) {
+  BlockEntryWithInitialDefs::WriteTo(s);
+}
+
+OsrEntryInstr::OsrEntryInstr(FlowGraphDeserializer* d)
+    : BlockEntryWithInitialDefs(d), graph_entry_(d->graph_entry()) {}
+
+void ParallelMoveInstr::WriteExtra(FlowGraphSerializer* s) {
+  Instruction::WriteExtra(s);
+  s->Write<GrowableArray<MoveOperands*>>(moves_);
+}
+
+void ParallelMoveInstr::ReadExtra(FlowGraphDeserializer* d) {
+  Instruction::ReadExtra(d);
+  moves_ = d->Read<GrowableArray<MoveOperands*>>();
+}
+
+void PhiInstr::WriteTo(FlowGraphSerializer* s) {
+  VariadicDefinition::WriteTo(s);
+  s->Write<Representation>(representation_);
+  s->Write<bool>(is_alive_);
+  s->Write<int8_t>(is_receiver_);
+}
+
+PhiInstr::PhiInstr(FlowGraphDeserializer* d)
+    : VariadicDefinition(d),
+      block_(d->current_block()->AsJoinEntry()),
+      representation_(d->Read<Representation>()),
+      is_alive_(d->Read<bool>()),
+      is_receiver_(d->Read<int8_t>()) {}
+
+template <>
+void FlowGraphSerializer::Write<Range*>(Range* x) {
+  if (x == nullptr) {
+    Write<bool>(false);
+  } else {
+    Write<bool>(true);
+    x->Write(this);
+  }
+}
+
+template <>
+Range* FlowGraphDeserializer::Read<Range*>() {
+  if (!Read<bool>()) {
+    return nullptr;
+  }
+  return new (Z) Range(this);
+}
+
+void Range::Write(FlowGraphSerializer* s) const {
+  min_.Write(s);
+  max_.Write(s);
+}
+
+Range::Range(FlowGraphDeserializer* d)
+    : min_(RangeBoundary(d)), max_(RangeBoundary(d)) {}
+
+void RangeBoundary::Write(FlowGraphSerializer* s) const {
+  s->Write<int8_t>(kind_);
+  s->Write<int64_t>(value_);
+  s->Write<int64_t>(offset_);
+}
+
+RangeBoundary::RangeBoundary(FlowGraphDeserializer* d)
+    : kind_(static_cast<Kind>(d->Read<int8_t>())),
+      value_(d->Read<int64_t>()),
+      offset_(d->Read<int64_t>()) {}
+
+void RegisterSet::Write(FlowGraphSerializer* s) const {
+  s->Write<uintptr_t>(cpu_registers_.data());
+  s->Write<uintptr_t>(untagged_cpu_registers_.data());
+  s->Write<uintptr_t>(fpu_registers_.data());
+}
+
+RegisterSet::RegisterSet(FlowGraphDeserializer* d)
+    : cpu_registers_(d->Read<uintptr_t>()),
+      untagged_cpu_registers_(d->Read<uintptr_t>()),
+      fpu_registers_(d->Read<uintptr_t>()) {}
+
+template <>
+void FlowGraphSerializer::Write<Representation>(Representation x) {
+  Write<uint8_t>(x);
+}
+
+template <>
+Representation FlowGraphDeserializer::Read<Representation>() {
+  return static_cast<Representation>(Read<uint8_t>());
+}
+
+template <>
+void FlowGraphSerializer::Write<const Slot&>(const Slot& x) {
+  x.Write(this);
+}
+
+template <>
+const Slot& FlowGraphDeserializer::Read<const Slot&>() {
+  return Slot::Read(this);
+}
+
+template <>
+void FlowGraphSerializer::Write<const Slot*>(const Slot* x) {
+  if (x == nullptr) {
+    Write<bool>(false);
+    return;
+  }
+  Write<bool>(true);
+  x->Write(this);
+}
+
+template <>
+const Slot* FlowGraphDeserializer::Read<const Slot*>() {
+  if (!Read<bool>()) {
+    return nullptr;
+  }
+  return &Slot::Read(this);
+}
+
+void Slot::Write(FlowGraphSerializer* s) const {
+  s->Write<serializable_type_t<Kind>>(
+      static_cast<serializable_type_t<Kind>>(kind_));
+
+  switch (kind_) {
+    case Kind::kTypeArguments:
+      s->Write<int8_t>(flags_);
+      s->Write<intptr_t>(offset_in_bytes_);
+      break;
+    case Kind::kTypeArgumentsIndex:
+      s->Write<intptr_t>(offset_in_bytes_);
+      break;
+    case Kind::kArrayElement:
+      s->Write<intptr_t>(offset_in_bytes_);
+      break;
+    case Kind::kCapturedVariable:
+      s->Write<int8_t>(flags_);
+      s->Write<intptr_t>(offset_in_bytes_);
+      s->Write<const String&>(*DataAs<const String>());
+      s->Write<const AbstractType&>(*static_type_);
+      break;
+    case Kind::kDartField:
+      s->Write<const Field&>(field());
+      break;
+    default:
+      break;
+  }
+}
+
+const Slot& Slot::Read(FlowGraphDeserializer* d) {
+  const Kind kind = static_cast<Kind>(d->Read<serializable_type_t<Kind>>());
+  int8_t flags = 0;
+  ClassIdTagType cid = kDynamicCid;
+  intptr_t offset = -1;
+  const void* data = nullptr;
+  const AbstractType* static_type = nullptr;
+  Representation representation = kTagged;
+
+  switch (kind) {
+    case Kind::kTypeArguments:
+      flags = d->Read<int8_t>();
+      offset = d->Read<intptr_t>();
+      cid = kTypeArgumentsCid;
+      data = ":type_arguments";
+      break;
+    case Kind::kTypeArgumentsIndex:
+      flags =
+          IsImmutableBit::encode(true) |
+          IsCompressedBit::encode(TypeArguments::ContainsCompressedPointers());
+      offset = d->Read<intptr_t>();
+      data = ":argument";
+      break;
+    case Kind::kArrayElement:
+      flags = IsNullableBit::encode(true) |
+              IsCompressedBit::encode(Array::ContainsCompressedPointers());
+      offset = d->Read<intptr_t>();
+      data = ":array_element";
+      break;
+    case Kind::kCapturedVariable:
+      flags = d->Read<int8_t>();
+      offset = d->Read<intptr_t>();
+      data = &d->Read<const String&>();
+      static_type = &d->Read<const AbstractType&>();
+      break;
+    case Kind::kDartField: {
+      const Field& field = d->Read<const Field&>();
+      return Slot::Get(field, &d->parsed_function());
+    }
+    default:
+      return Slot::GetNativeSlot(kind);
+  }
+
+  return GetCanonicalSlot(d->thread(), kind, flags, cid, offset, data,
+                          static_type, representation);
+}
+
+template <>
+void FlowGraphSerializer::Write<const compiler::TableSelector*>(
+    const compiler::TableSelector* x) {
+#if defined(DART_PRECOMPILER)
+  ASSERT(x != nullptr);
+  Write<int32_t>(x->id);
+#else
+  UNREACHABLE();
+#endif
+}
+
+template <>
+const compiler::TableSelector*
+FlowGraphDeserializer::Read<const compiler::TableSelector*>() {
+#if defined(DART_PRECOMPILER)
+  const int32_t id = Read<int32_t>();
+  const compiler::TableSelector* selector =
+      Precompiler::Instance()->selector_map()->GetSelector(id);
+  ASSERT(selector != nullptr);
+  return selector;
+#else
+  UNREACHABLE();
+#endif
+}
+
+void SpecialParameterInstr::WriteExtra(FlowGraphSerializer* s) {
+  TemplateDefinition::WriteExtra(s);
+  s->WriteRef<BlockEntryInstr*>(block_);
+}
+
+void SpecialParameterInstr::ReadExtra(FlowGraphDeserializer* d) {
+  TemplateDefinition::ReadExtra(d);
+  block_ = d->ReadRef<BlockEntryInstr*>();
+}
+
+template <intptr_t kExtraInputs>
+void TemplateDartCall<kExtraInputs>::WriteExtra(FlowGraphSerializer* s) {
+  VariadicDefinition::WriteExtra(s);
+  if (push_arguments_ == nullptr) {
+    s->Write<intptr_t>(-1);
+  } else {
+    s->Write<intptr_t>(push_arguments_->length());
+#if defined(DEBUG)
+    // Verify that PushArgument instructions are inserted immediately
+    // before this instruction. ReadExtra below relies on
+    // that when restoring push_arguments_.
+    Instruction* instr = this;
+    for (intptr_t i = push_arguments_->length() - 1; i >= 0; --i) {
+      do {
+        instr = instr->previous();
+        ASSERT(instr != nullptr);
+      } while (!instr->IsPushArgument());
+      ASSERT(instr == (*push_arguments_)[i]);
+    }
+#endif
+  }
+}
+
+template <intptr_t kExtraInputs>
+void TemplateDartCall<kExtraInputs>::ReadExtra(FlowGraphDeserializer* d) {
+  VariadicDefinition::ReadExtra(d);
+  const intptr_t num_push_args = d->Read<intptr_t>();
+  if (num_push_args >= 0) {
+    push_arguments_ =
+        new (d->zone()) PushArgumentsArray(d->zone(), num_push_args);
+    push_arguments_->EnsureLength(num_push_args, nullptr);
+    Instruction* instr = this;
+    for (int i = num_push_args - 1; i >= 0; --i) {
+      do {
+        instr = instr->previous();
+        ASSERT(instr != nullptr);
+      } while (!instr->IsPushArgument());
+      (*push_arguments_)[i] = instr->AsPushArgument();
+    }
+    if (env() != nullptr) {
+      RepairPushArgsInEnvironment();
+    }
+  }
+}
+
+// Explicit template instantiations, needed for the methods above.
+template class TemplateDartCall<0>;
+template class TemplateDartCall<1>;
+
+template <>
+void FlowGraphSerializer::Write<TokenPosition>(TokenPosition x) {
+  Write<int32_t>(x.Serialize());
+}
+
+template <>
+TokenPosition FlowGraphDeserializer::Read<TokenPosition>() {
+  return TokenPosition::Deserialize(Read<int32_t>());
+}
+
+template <>
+void FlowGraphSerializer::Write<uint8_t>(uint8_t x) {
+  stream_->Write<uint8_t>(x);
+}
+
+template <>
+uint8_t FlowGraphDeserializer::Read<uint8_t>() {
+  return stream_->Read<uint8_t>();
+}
+
+template <>
+void FlowGraphSerializer::Write<uint16_t>(uint16_t x) {
+  stream_->Write<uint16_t>(x);
+}
+
+template <>
+uint16_t FlowGraphDeserializer::Read<uint16_t>() {
+  return stream_->Read<uint16_t>();
+}
+
+template <>
+void FlowGraphSerializer::Write<uint32_t>(uint32_t x) {
+  stream_->Write<int32_t>(static_cast<int32_t>(x));
+}
+
+template <>
+uint32_t FlowGraphDeserializer::Read<uint32_t>() {
+  return static_cast<uint32_t>(stream_->Read<int32_t>());
+}
+
+template <>
+void FlowGraphSerializer::Write<uint64_t>(uint64_t x) {
+  stream_->Write<int64_t>(static_cast<int64_t>(x));
+}
+
+template <>
+uint64_t FlowGraphDeserializer::Read<uint64_t>() {
+  return static_cast<uint64_t>(stream_->Read<int64_t>());
+}
+
+void UnboxedConstantInstr::WriteTo(FlowGraphSerializer* s) {
+  ConstantInstr::WriteTo(s);
+  s->Write<Representation>(representation_);
+  // constant_address_ is not written - it is restored when reading.
+}
+
+UnboxedConstantInstr::UnboxedConstantInstr(FlowGraphDeserializer* d)
+    : ConstantInstr(d),
+      representation_(d->Read<Representation>()),
+      constant_address_(0) {
+  if (representation_ == kUnboxedDouble) {
+    ASSERT(value().IsDouble());
+    constant_address_ = FindDoubleConstant(Double::Cast(value()).value());
+  }
+}
+
+template <>
+void FlowGraphSerializer::Write<Value*>(Value* x) {
+  ASSERT(can_write_refs());
+  CompileType* reaching_type = x->reaching_type();
+  Definition* def = x->definition();
+  // Omit reaching type if it is the same as definition type.
+  if ((reaching_type != nullptr) && def->HasType() &&
+      (reaching_type == def->Type())) {
+    reaching_type = nullptr;
+  }
+  Write<CompileType*>(reaching_type);
+  WriteRef<Definition*>(def);
+}
+
+template <>
+Value* FlowGraphDeserializer::Read<Value*>() {
+  CompileType* type = Read<CompileType*>();
+  Definition* def = ReadRef<Definition*>();
+  Value* value = new (Z) Value(def);
+  value->SetReachingType(type);
+  return value;
+}
+
+void VariadicDefinition::WriteTo(FlowGraphSerializer* s) {
+  Definition::WriteTo(s);
+  s->Write<intptr_t>(inputs_.length());
+}
+
+VariadicDefinition::VariadicDefinition(FlowGraphDeserializer* d)
+    : Definition(d), inputs_(d->zone(), 0) {
+  const intptr_t num_inputs = d->Read<intptr_t>();
+  inputs_.EnsureLength(num_inputs, nullptr);
+}
+
+}  // namespace dart
diff --git a/runtime/vm/compiler/backend/il_serializer.h b/runtime/vm/compiler/backend/il_serializer.h
new file mode 100644
index 0000000..07948c2
--- /dev/null
+++ b/runtime/vm/compiler/backend/il_serializer.h
@@ -0,0 +1,473 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#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 <utility>  // For std::move.
+
+#include "platform/globals.h"
+#include "vm/allocation.h"
+#include "vm/compiler/backend/locations.h"
+
+namespace dart {
+
+class AliasIdentity;
+class BlockEntryInstr;
+class CallTargets;
+class CatchBlockEntryInstr;
+struct CidRangeValue;
+class Cids;
+class Code;
+class ComparisonInstr;
+class CompileType;
+class Definition;
+class Environment;
+class FunctionEntryInstr;
+class Instruction;
+class FlowGraph;
+class GraphEntryInstr;
+class Heap;
+class IndirectEntryInstr;
+class JoinEntryInstr;
+class LocalVariable;
+class LocationSummary;
+class MoveOperands;
+class NonStreamingWriteStream;
+class OsrEntryInstr;
+class ParsedFunction;
+class ParallelMoveInstr;
+class PhiInstr;
+class Range;
+class ReadStream;
+class TargetEntryInstr;
+class TokenPosition;
+
+namespace compiler {
+struct TableSelector;
+
+namespace ffi {
+class CallbackMarshaller;
+class CallMarshaller;
+class NativeCallingConvention;
+}  // namespace ffi
+}  // namespace compiler
+
+// The list of types which are handled by flow graph serializer/deserializer.
+// For each type there is a corresponding Write<T>(T) and Read<T>() methods.
+//
+// This list includes all types of fields of IL instructions
+// which are serialized via DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS macro,
+// except enum types which are unwrapped with serializable_type_t.
+//
+// The list is sorted alphabetically by type name.
+#define IL_SERIALIZABLE_TYPE_LIST(V)                                           \
+  V(AliasIdentity)                                                             \
+  V(const AbstractType&)                                                       \
+  V(const AbstractType*)                                                       \
+  V(const Array&)                                                              \
+  V(bool)                                                                      \
+  V(const compiler::ffi::CallbackMarshaller&)                                  \
+  V(const compiler::ffi::CallMarshaller&)                                      \
+  V(const CallTargets&)                                                        \
+  V(const char*)                                                               \
+  V(CidRangeValue)                                                             \
+  V(const Cids&)                                                               \
+  V(const Class&)                                                              \
+  V(const Code&)                                                               \
+  V(ComparisonInstr*)                                                          \
+  V(CompileType*)                                                              \
+  V(ConstantInstr*)                                                            \
+  V(Definition*)                                                               \
+  V(double)                                                                    \
+  V(Environment*)                                                              \
+  V(const Field&)                                                              \
+  V(const ICData*)                                                             \
+  V(int8_t)                                                                    \
+  V(int16_t)                                                                   \
+  V(int32_t)                                                                   \
+  V(int64_t)                                                                   \
+  V(const Function&)                                                           \
+  V(const FunctionType&)                                                       \
+  V(Instruction*)                                                              \
+  V(const LocalVariable&)                                                      \
+  V(LocationSummary*)                                                          \
+  V(MoveOperands*)                                                             \
+  V(const compiler::ffi::NativeCallingConvention&)                             \
+  V(const Object&)                                                             \
+  V(ParallelMoveInstr*)                                                        \
+  V(PhiInstr*)                                                                 \
+  V(Range*)                                                                    \
+  V(Representation)                                                            \
+  V(const Slot&)                                                               \
+  V(const Slot*)                                                               \
+  V(const String&)                                                             \
+  V(const compiler::TableSelector*)                                            \
+  V(TokenPosition)                                                             \
+  V(const TypeArguments&)                                                      \
+  V(const TypeParameters&)                                                     \
+  V(uint8_t)                                                                   \
+  V(uint16_t)                                                                  \
+  V(uint32_t)                                                                  \
+  V(uint64_t)                                                                  \
+  V(Value*)
+
+// List of types serializable as references.
+#define IL_SERIALIZABLE_REF_TYPE_LIST(V)                                       \
+  V(BlockEntryInstr*)                                                          \
+  V(CatchBlockEntryInstr*)                                                     \
+  V(Definition*)                                                               \
+  V(FunctionEntryInstr*)                                                       \
+  V(IndirectEntryInstr*)                                                       \
+  V(JoinEntryInstr*)                                                           \
+  V(OsrEntryInstr*)                                                            \
+  V(TargetEntryInstr*)
+
+// Serializes flow graph, including constants and references
+// to objects of program structure.
+//
+// Each IL instruction is serialized in 2 step:
+// - the main step (T::WriteTo / T::T()) serializes
+//   instruction fields, basically everything required to
+//   re-create instruction object.
+// - the extra step (T::WriteExtra / T::ReadExtra) serializes
+//   references to other instructions, including inputs,
+//   environments, locations (may reference constants) and successors.
+//
+class FlowGraphSerializer : public ValueObject {
+ public:
+  explicit FlowGraphSerializer(NonStreamingWriteStream* stream);
+  ~FlowGraphSerializer();
+
+  // Writes [flow_graph] into the stream.
+  // The graph should be compacted via CompactSSA().
+  // [detached_defs] should contain all definitions which are
+  // detached from the graph but can still be referenced from
+  // environments.
+  void WriteFlowGraph(const FlowGraph& flow_graph,
+                      const ZoneGrowableArray<Definition*>& detached_defs);
+
+  // Default implementation of 'Write' method, when
+  // specialization for a particular type is not provided.
+  // This struct is used for the partial template instantiations below.
+  template <typename T>
+  struct WriteTrait {
+    using ArgType = T;
+  };
+
+  template <typename T>
+  struct WriteTrait<GrowableArray<T>> {
+    using ArgType = const GrowableArray<T>&;
+    static void Write(FlowGraphSerializer* s, ArgType x) {
+      const intptr_t len = x.length();
+      s->Write<intptr_t>(len);
+      for (intptr_t i = 0; i < len; ++i) {
+        s->Write<T>(x[i]);
+      }
+    }
+  };
+
+  template <typename T>
+  struct WriteTrait<const GrowableArray<T>&> {
+    using ArgType = const GrowableArray<T>&;
+    static void Write(FlowGraphSerializer* s, ArgType x) {
+      WriteTrait<GrowableArray<T>>::Write(s, x);
+    }
+  };
+
+  template <typename T>
+  struct WriteTrait<ZoneGrowableArray<T>*> {
+    using ArgType = const ZoneGrowableArray<T>*;
+    static void Write(FlowGraphSerializer* s, ArgType x) {
+      if (x == nullptr) {
+        s->Write<intptr_t>(-1);
+        return;
+      }
+      const intptr_t len = x->length();
+      s->Write<intptr_t>(len);
+      for (intptr_t i = 0; i < len; ++i) {
+        s->Write<T>((*x)[i]);
+      }
+    }
+  };
+
+  template <typename T>
+  struct WriteTrait<const ZoneGrowableArray<T>&> {
+    using ArgType = const ZoneGrowableArray<T>&;
+    static void Write(FlowGraphSerializer* s, ArgType x) {
+      WriteTrait<ZoneGrowableArray<T>*>::Write(s, &x);
+    }
+  };
+
+  // Specialization in case intptr_t is not mapped to intN_t.
+  template <>
+  struct WriteTrait<intptr_t> {
+    using ArgType = intptr_t;
+    static void Write(FlowGraphSerializer* s, intptr_t x) {
+#ifdef ARCH_IS_64_BIT
+      s->Write<int64_t>(x);
+#else
+      s->Write<int32_t>(x);
+#endif
+    }
+  };
+
+  // Specialization in case uintptr_t is not mapped to uintN_t.
+  template <>
+  struct WriteTrait<uintptr_t> {
+    using ArgType = uintptr_t;
+    static void Write(FlowGraphSerializer* s, uintptr_t x) {
+#ifdef ARCH_IS_64_BIT
+      s->Write<uint64_t>(x);
+#else
+      s->Write<uint32_t>(x);
+#endif
+    }
+  };
+
+  template <typename T>
+  void Write(typename WriteTrait<T>::ArgType x) {
+    WriteTrait<T>::Write(this, x);
+  }
+
+#define DECLARE_WRITE_METHOD(type)                                             \
+  template <>                                                                  \
+  void Write<type>(type x);
+  IL_SERIALIZABLE_TYPE_LIST(DECLARE_WRITE_METHOD)
+#undef DECLARE_WRITE_METHOD
+
+  template <typename T>
+  void WriteRef(T x);
+
+#define DECLARE_WRITE_REF_METHOD(type)                                         \
+  template <>                                                                  \
+  void WriteRef<type>(type x);
+  IL_SERIALIZABLE_REF_TYPE_LIST(DECLARE_WRITE_REF_METHOD)
+#undef DECLARE_WRITE_REF_METHOD
+
+  template <typename T>
+  void WriteGrowableArrayOfRefs(const GrowableArray<T>& array) {
+    const intptr_t len = array.length();
+    Write<intptr_t>(len);
+    for (intptr_t i = 0; i < len; ++i) {
+      WriteRef<T>(array[i]);
+    }
+  }
+
+  BaseWriteStream* stream() const { return stream_; }
+  IsolateGroup* isolate_group() const { return isolate_group_; }
+  bool can_write_refs() const { return can_write_refs_; }
+
+ private:
+  void WriteObjectImpl(const Object& x, intptr_t cid, intptr_t object_index);
+
+  // Used to track scopes of recursive types during serialization.
+  struct TypeScope {
+    TypeScope(FlowGraphSerializer* serializer, bool is_recursive)
+        : serializer_(serializer),
+          is_recursive_(is_recursive),
+          was_writing_recursive_type_(serializer->writing_recursive_type_) {
+      serializer->writing_recursive_type_ = is_recursive;
+    }
+
+    ~TypeScope() {
+      serializer_->writing_recursive_type_ = was_writing_recursive_type_;
+    }
+
+    // Returns true if type of the current scope can be canonicalized
+    // during deserialization. Recursive types which were not
+    // fully deserialized should not be canonicalized.
+    bool CanBeCanonicalized() const {
+      return !is_recursive_ || !was_writing_recursive_type_;
+    }
+
+    FlowGraphSerializer* const serializer_;
+    const bool is_recursive_;
+    const bool was_writing_recursive_type_;
+  };
+
+  NonStreamingWriteStream* stream_;
+  Zone* zone_;
+  IsolateGroup* isolate_group_;
+  Heap* heap_;
+  intptr_t object_counter_ = 0;
+  bool can_write_refs_ = false;
+  bool writing_recursive_type_ = false;
+};
+
+// Deserializes flow graph.
+// All constants and types are canonicalized during deserialization.
+class FlowGraphDeserializer : public ValueObject {
+ public:
+  FlowGraphDeserializer(const ParsedFunction& parsed_function,
+                        ReadStream* stream);
+
+  const ParsedFunction& parsed_function() const { return parsed_function_; }
+
+  Zone* zone() const { return zone_; }
+  ReadStream* stream() const { return stream_; }
+  Thread* thread() const { return thread_; }
+  IsolateGroup* isolate_group() const { return isolate_group_; }
+
+  GraphEntryInstr* graph_entry() const { return graph_entry_; }
+  void set_graph_entry(GraphEntryInstr* entry) { graph_entry_ = entry; }
+
+  BlockEntryInstr* current_block() const { return current_block_; }
+  void set_current_block(BlockEntryInstr* block) { current_block_ = block; }
+
+  BlockEntryInstr* block(intptr_t block_id) const {
+    BlockEntryInstr* b = blocks_[block_id];
+    ASSERT(b != nullptr);
+    return b;
+  }
+  void set_block(intptr_t block_id, BlockEntryInstr* block) {
+    ASSERT(blocks_[block_id] == nullptr);
+    blocks_[block_id] = block;
+  }
+
+  Definition* definition(intptr_t ssa_temp_index) const {
+    Definition* def = definitions_[ssa_temp_index];
+    ASSERT(def != nullptr);
+    return def;
+  }
+  void set_definition(intptr_t ssa_temp_index, Definition* def) {
+    ASSERT(definitions_[ssa_temp_index] == nullptr);
+    definitions_[ssa_temp_index] = def;
+  }
+
+  FlowGraph* ReadFlowGraph();
+
+  // Default implementation of 'Read' method, when
+  // specialization for a particular type is not provided.
+  // This struct is used for the partial template instantiations below.
+  template <typename T>
+  struct ReadTrait {};
+
+  template <typename T>
+  struct ReadTrait<GrowableArray<T>> {
+    static GrowableArray<T> Read(FlowGraphDeserializer* d) {
+      const intptr_t len = d->Read<intptr_t>();
+      GrowableArray<T> array(len);
+      for (int i = 0; i < len; ++i) {
+        array.Add(d->Read<T>());
+      }
+      return array;
+    }
+  };
+
+  template <typename T>
+  struct ReadTrait<const GrowableArray<T>&> {
+    static const GrowableArray<T>& Read(FlowGraphDeserializer* d) {
+      return ReadTrait<GrowableArray<T>>::Read(d);
+    }
+  };
+
+  template <typename T>
+  struct ReadTrait<ZoneGrowableArray<T>*> {
+    static ZoneGrowableArray<T>* Read(FlowGraphDeserializer* d) {
+      const intptr_t len = d->Read<intptr_t>();
+      if (len < 0) {
+        return nullptr;
+      }
+      auto* array = new (d->zone()) ZoneGrowableArray<T>(d->zone(), len);
+      for (int i = 0; i < len; ++i) {
+        array->Add(d->Read<T>());
+      }
+      return array;
+    }
+  };
+
+  template <typename T>
+  struct ReadTrait<const ZoneGrowableArray<T>&> {
+    static const ZoneGrowableArray<T>& Read(FlowGraphDeserializer* d) {
+      return *ReadTrait<ZoneGrowableArray<T>*>::Read(d);
+    }
+  };
+
+  // Specialization in case intptr_t is not mapped to intN_t.
+  template <>
+  struct ReadTrait<intptr_t> {
+    static intptr_t Read(FlowGraphDeserializer* d) {
+#ifdef ARCH_IS_64_BIT
+      return d->Read<int64_t>();
+#else
+      return d->Read<int32_t>();
+#endif
+    }
+  };
+
+  // Specialization in case uintptr_t is not mapped to uintN_t.
+  template <>
+  struct ReadTrait<uintptr_t> {
+    static uintptr_t Read(FlowGraphDeserializer* d) {
+#ifdef ARCH_IS_64_BIT
+      return d->Read<uint64_t>();
+#else
+      return d->Read<uint32_t>();
+#endif
+    }
+  };
+
+  template <typename T>
+  T Read() {
+    return ReadTrait<T>::Read(this);
+  }
+
+#define DECLARE_READ_METHOD(type)                                              \
+  template <>                                                                  \
+  type Read<type>();
+  IL_SERIALIZABLE_TYPE_LIST(DECLARE_READ_METHOD)
+#undef DECLARE_READ_METHOD
+
+  template <typename T>
+  T ReadRef();
+
+#define DECLARE_READ_REF_METHOD(type)                                          \
+  template <>                                                                  \
+  type ReadRef<type>();
+  IL_SERIALIZABLE_REF_TYPE_LIST(DECLARE_READ_REF_METHOD)
+#undef DECLARE_READ_REF_METHOD
+
+  template <typename T>
+  GrowableArray<T> ReadGrowableArrayOfRefs() {
+    const intptr_t len = Read<intptr_t>();
+    GrowableArray<T> array(len);
+    for (int i = 0; i < len; ++i) {
+      array.Add(ReadRef<T>());
+    }
+    return std::move(array);
+  }
+
+ private:
+  ClassPtr GetClassById(classid_t id) const;
+  const Object& ReadObjectImpl(intptr_t cid, intptr_t object_index);
+  void SetObjectAt(intptr_t object_index, const Object& object);
+
+  InstancePtr MaybeCanonicalize(const Instance& obj,
+                                intptr_t object_index,
+                                bool can_be_canonicalized);
+
+  const ParsedFunction& parsed_function_;
+  ReadStream* stream_;
+  Zone* zone_;
+  Thread* thread_;
+  IsolateGroup* isolate_group_;
+
+  // Deserialized objects.
+  GraphEntryInstr* graph_entry_ = nullptr;
+  BlockEntryInstr* current_block_ = nullptr;
+  GrowableArray<BlockEntryInstr*> blocks_;
+  GrowableArray<Definition*> definitions_;
+  GrowableArray<const Object*> objects_;
+  intptr_t object_counter_ = 0;
+  GrowableArray<intptr_t> pending_canonicalization_;
+};
+
+}  // namespace dart
+
+#endif  // RUNTIME_VM_COMPILER_BACKEND_IL_SERIALIZER_H_
diff --git a/runtime/vm/compiler/backend/locations.h b/runtime/vm/compiler/backend/locations.h
index aabd12a..c82215f 100644
--- a/runtime/vm/compiler/backend/locations.h
+++ b/runtime/vm/compiler/backend/locations.h
@@ -21,6 +21,8 @@
 class BaseTextBuffer;
 class ConstantInstr;
 class Definition;
+class FlowGraphDeserializer;
+class FlowGraphSerializer;
 class PairLocation;
 class Value;
 
@@ -430,8 +432,8 @@
 
   Location Copy() const;
 
-  static Location read(uword value) { return Location(value); }
-  uword write() const { return value_; }
+  void Write(FlowGraphSerializer* s) const;
+  static Location Read(FlowGraphDeserializer* d);
 
  private:
   explicit Location(uword value) : value_(value) {}
@@ -572,8 +574,7 @@
     ASSERT(kNumberOfFpuRegisters <= (kWordSize * kBitsPerByte));
   }
 
-  explicit RegisterSet(uintptr_t cpu_register_mask,
-                       uintptr_t fpu_register_mask = 0)
+  explicit RegisterSet(uintptr_t cpu_register_mask, uintptr_t fpu_register_mask)
       : RegisterSet() {
     AddTaggedRegisters(cpu_register_mask, fpu_register_mask);
   }
@@ -717,6 +718,9 @@
     untagged_cpu_registers_.Clear();
   }
 
+  void Write(FlowGraphSerializer* s) const;
+  explicit RegisterSet(FlowGraphDeserializer* d);
+
  private:
   SmallSet<Register> cpu_registers_;
   SmallSet<Register> untagged_cpu_registers_;
@@ -835,6 +839,9 @@
   void CheckWritableInputs();
 #endif
 
+  void Write(FlowGraphSerializer* s) const;
+  explicit LocationSummary(FlowGraphDeserializer* d);
+
  private:
   BitmapBuilder& EnsureStackBitmap() {
     if (stack_bitmap_ == NULL) {
diff --git a/runtime/vm/compiler/backend/range_analysis.cc b/runtime/vm/compiler/backend/range_analysis.cc
index f2cf0ab..9025738 100644
--- a/runtime/vm/compiler/backend/range_analysis.cc
+++ b/runtime/vm/compiler/backend/range_analysis.cc
@@ -1815,7 +1815,7 @@
   int64_t value = value_boundary.ConstantValue();
 
   if (value == 0) {
-    return RangeBoundary(0);
+    return RangeBoundary::FromConstant(0);
   } else if (shift_count == 0 ||
              (limit > 0 && Utils::IsInt(static_cast<int>(limit), value))) {
     // Result stays in 64 bit range.
diff --git a/runtime/vm/compiler/backend/range_analysis.h b/runtime/vm/compiler/backend/range_analysis.h
index aa1f6b9..dc178f6 100644
--- a/runtime/vm/compiler/backend/range_analysis.h
+++ b/runtime/vm/compiler/backend/range_analysis.h
@@ -301,6 +301,9 @@
 
   int64_t SmiLowerBound() const { return LowerBound(kRangeBoundarySmi); }
 
+  void Write(FlowGraphSerializer* s) const;
+  explicit RangeBoundary(FlowGraphDeserializer* d);
+
  private:
   RangeBoundary(Kind kind, int64_t value, int64_t offset)
       : kind_(kind), value_(value), offset_(offset) {}
@@ -536,6 +539,9 @@
                        Definition* left_defn,
                        Range* result);
 
+  void Write(FlowGraphSerializer* s) const;
+  explicit Range(FlowGraphDeserializer* d);
+
  private:
   RangeBoundary min_;
   RangeBoundary max_;
diff --git a/runtime/vm/compiler/backend/range_analysis_test.cc b/runtime/vm/compiler/backend/range_analysis_test.cc
index ce2d3d5..39b4729 100644
--- a/runtime/vm/compiler/backend/range_analysis_test.cc
+++ b/runtime/vm/compiler/backend/range_analysis_test.cc
@@ -82,13 +82,14 @@
                       RangeBoundary(compiler::target::kSmiMin),
                       RangeBoundary(compiler::target::kSmiMax));
   }
-  TEST_RANGE_OP(Range::Shl, 0, 100, 0, 64, RangeBoundary(0),
+  TEST_RANGE_OP(Range::Shl, 0, 100, 0, 64, RangeBoundary::FromConstant(0),
                 RangeBoundary::PositiveInfinity());
   TEST_RANGE_OP(Range::Shl, -100, 0, 0, 64, RangeBoundary::NegativeInfinity(),
-                RangeBoundary(0));
+                RangeBoundary::FromConstant(0));
 
   TEST_RANGE_OP(Range::Shr, -8, 8, 1, 2, RangeBoundary(-4), RangeBoundary(4));
-  TEST_RANGE_OP(Range::Shr, 1, 8, 1, 2, RangeBoundary(0), RangeBoundary(4));
+  TEST_RANGE_OP(Range::Shr, 1, 8, 1, 2, RangeBoundary::FromConstant(0),
+                RangeBoundary(4));
   TEST_RANGE_OP(Range::Shr, -16, -8, 1, 2, RangeBoundary(-8),
                 RangeBoundary(-2));
   TEST_RANGE_OP(Range::Shr, 2, 4, -1, 1, RangeBoundary(1), RangeBoundary(4));
@@ -466,24 +467,26 @@
   // [0xff, 0xfff] & [0xf, 0xf] = [0x0, 0xf].
   TEST_RANGE_AND(static_cast<int64_t>(0xff), static_cast<int64_t>(0xfff),
                  static_cast<int64_t>(0xf), static_cast<int64_t>(0xf),
-                 RangeBoundary(0), RangeBoundary(0xf));
+                 RangeBoundary::FromConstant(0), RangeBoundary(0xf));
 
   // [0xffffffff, 0xffffffff] & [0xfffffffff, 0xfffffffff] = [0x0, 0xfffffffff].
   TEST_RANGE_AND(
       static_cast<int64_t>(0xffffffff), static_cast<int64_t>(0xffffffff),
       static_cast<int64_t>(0xfffffffff), static_cast<int64_t>(0xfffffffff),
-      RangeBoundary(0), RangeBoundary(static_cast<int64_t>(0xfffffffff)));
+      RangeBoundary::FromConstant(0),
+      RangeBoundary(static_cast<int64_t>(0xfffffffff)));
 
   // [0xffffffff, 0xffffffff] & [-20, 20] = [0x0, 0xffffffff].
   TEST_RANGE_AND(static_cast<int64_t>(0xffffffff),
                  static_cast<int64_t>(0xffffffff), static_cast<int64_t>(-20),
-                 static_cast<int64_t>(20), RangeBoundary(0),
+                 static_cast<int64_t>(20), RangeBoundary::FromConstant(0),
                  RangeBoundary(static_cast<int64_t>(0xffffffff)));
 
   // [-20, 20] & [0xffffffff, 0xffffffff] = [0x0, 0xffffffff].
   TEST_RANGE_AND(static_cast<int64_t>(-20), static_cast<int64_t>(20),
                  static_cast<int64_t>(0xffffffff),
-                 static_cast<int64_t>(0xffffffff), RangeBoundary(0),
+                 static_cast<int64_t>(0xffffffff),
+                 RangeBoundary::FromConstant(0),
                  RangeBoundary(static_cast<int64_t>(0xffffffff)));
 
   // Test that [-20, 20] & [-20, 20] = [-32, 31].
diff --git a/runtime/vm/compiler/backend/redundancy_elimination.cc b/runtime/vm/compiler/backend/redundancy_elimination.cc
index c192500..454cae9 100644
--- a/runtime/vm/compiler/backend/redundancy_elimination.cc
+++ b/runtime/vm/compiler/backend/redundancy_elimination.cc
@@ -3676,8 +3676,10 @@
 // Remove materializations from the graph. Register allocator will treat them
 // as part of the environment not as a real instruction.
 void AllocationSinking::DetachMaterializations() {
-  for (intptr_t i = 0; i < materializations_.length(); i++) {
-    materializations_[i]->previous()->LinkTo(materializations_[i]->next());
+  for (MaterializeObjectInstr* mat : materializations_) {
+    mat->previous()->LinkTo(mat->next());
+    mat->set_next(nullptr);
+    mat->set_previous(nullptr);
   }
 }
 
diff --git a/runtime/vm/compiler/backend/slot.cc b/runtime/vm/compiler/backend/slot.cc
index 6554f8b..46acba6 100644
--- a/runtime/vm/compiler/backend/slot.cc
+++ b/runtime/vm/compiler/backend/slot.cc
@@ -302,48 +302,60 @@
   const intptr_t offset =
       compiler::target::Class::TypeArgumentsFieldOffset(cls);
   ASSERT(offset != Class::kNoTypeArguments);
-  return SlotCache::Instance(thread).Canonicalize(
-      Slot(Kind::kTypeArguments,
-           IsImmutableBit::encode(true) |
-               IsCompressedBit::encode(
-                   compiler::target::Class::HasCompressedPointers(cls)),
-           kTypeArgumentsCid, offset, ":type_arguments",
-           /*static_type=*/nullptr, kTagged));
+  return GetCanonicalSlot(
+      thread, Kind::kTypeArguments,
+      IsImmutableBit::encode(true) |
+          IsCompressedBit::encode(
+              compiler::target::Class::HasCompressedPointers(cls)),
+      kTypeArgumentsCid, offset, ":type_arguments",
+      /*static_type=*/nullptr, kTagged);
 }
 
 const Slot& Slot::GetContextVariableSlotFor(Thread* thread,
                                             const LocalVariable& variable) {
   ASSERT(variable.is_captured());
-  return SlotCache::Instance(thread).Canonicalize(
-      Slot(Kind::kCapturedVariable,
-           IsImmutableBit::encode(variable.is_final() && !variable.is_late()) |
-               IsNullableBit::encode(true) |
-               IsCompressedBit::encode(Context::ContainsCompressedPointers()) |
-               IsSentinelVisibleBit::encode(variable.is_late()),
-           kDynamicCid,
-           compiler::target::Context::variable_offset(variable.index().value()),
-           &variable.name(), &variable.type(), kTagged));
+  return GetCanonicalSlot(
+      thread, Kind::kCapturedVariable,
+      IsImmutableBit::encode(variable.is_final() && !variable.is_late()) |
+          IsNullableBit::encode(true) |
+          IsCompressedBit::encode(Context::ContainsCompressedPointers()) |
+          IsSentinelVisibleBit::encode(variable.is_late()),
+      kDynamicCid,
+      compiler::target::Context::variable_offset(variable.index().value()),
+      &variable.name(), &variable.type(), kTagged);
 }
 
 const Slot& Slot::GetTypeArgumentsIndexSlot(Thread* thread, intptr_t index) {
   const intptr_t offset =
       compiler::target::TypeArguments::type_at_offset(index);
-  const Slot& slot = Slot(
-      Kind::kTypeArgumentsIndex,
+  return GetCanonicalSlot(
+      thread, Kind::kTypeArgumentsIndex,
       IsImmutableBit::encode(true) |
           IsCompressedBit::encode(TypeArguments::ContainsCompressedPointers()),
       kDynamicCid, offset, ":argument", /*static_type=*/nullptr, kTagged);
-  return SlotCache::Instance(thread).Canonicalize(slot);
 }
 
 const Slot& Slot::GetArrayElementSlot(Thread* thread,
                                       intptr_t offset_in_bytes) {
-  const Slot& slot =
-      Slot(Kind::kArrayElement,
-           IsNullableBit::encode(true) |
-               IsCompressedBit::encode(Array::ContainsCompressedPointers()),
-           kDynamicCid, offset_in_bytes, ":array_element",
-           /*static_type=*/nullptr, kTagged);
+  return GetCanonicalSlot(
+      thread, Kind::kArrayElement,
+      IsNullableBit::encode(true) |
+          IsCompressedBit::encode(Array::ContainsCompressedPointers()),
+      kDynamicCid, offset_in_bytes, ":array_element",
+      /*static_type=*/nullptr, kTagged);
+}
+
+const Slot& Slot::GetCanonicalSlot(Thread* thread,
+                                   Slot::Kind kind,
+                                   int8_t flags,
+                                   ClassIdTagType cid,
+                                   intptr_t offset_in_bytes,
+                                   const void* data,
+                                   const AbstractType* static_type,
+                                   Representation representation,
+                                   const FieldGuardState& field_guard_state) {
+  const Slot& slot = Slot(kind, flags, cid, offset_in_bytes, data, static_type,
+                          representation, field_guard_state);
   return SlotCache::Instance(thread).Canonicalize(slot);
 }
 
@@ -456,8 +468,8 @@
   }
 
   Class& owner = Class::Handle(zone, field.Owner());
-  const Slot& slot = SlotCache::Instance(thread).Canonicalize(Slot(
-      Kind::kDartField,
+  const Slot& slot = GetCanonicalSlot(
+      thread, Kind::kDartField,
       IsImmutableBit::encode((field.is_final() && !field.is_late()) ||
                              field.is_const()) |
           IsNullableBit::encode(is_nullable) |
@@ -467,7 +479,7 @@
           IsSentinelVisibleBit::encode(field.is_late() && field.is_final() &&
                                        !field.has_initializer()),
       nullable_cid, compiler::target::Field::OffsetOf(field), &field, &type,
-      rep, field_guard_state));
+      rep, field_guard_state);
 
   // If properties of this slot were based on the guarded state make sure
   // to add the field to the list of guarded fields. Note that during background
diff --git a/runtime/vm/compiler/backend/slot.h b/runtime/vm/compiler/backend/slot.h
index eb87355..90838c9 100644
--- a/runtime/vm/compiler/backend/slot.h
+++ b/runtime/vm/compiler/backend/slot.h
@@ -357,9 +357,12 @@
   bool IsPotentialUnboxed() const;
   Representation UnboxedRepresentation() const;
 
+  void Write(FlowGraphSerializer* s) const;
+  static const Slot& Read(FlowGraphDeserializer* d);
+
  private:
   Slot(Kind kind,
-       int8_t bits,
+       int8_t flags,
        ClassIdTagType cid,
        intptr_t offset_in_bytes,
        const void* data,
@@ -367,7 +370,7 @@
        Representation representation,
        const FieldGuardState& field_guard_state = FieldGuardState())
       : kind_(kind),
-        flags_(bits),
+        flags_(flags),
         cid_(cid),
         offset_in_bytes_(offset_in_bytes),
         representation_(representation),
@@ -397,6 +400,17 @@
     return static_cast<const T*>(data_);
   }
 
+  static const Slot& GetCanonicalSlot(
+      Thread* thread,
+      Kind kind,
+      int8_t flags,
+      ClassIdTagType cid,
+      intptr_t offset_in_bytes,
+      const void* data,
+      const AbstractType* static_type,
+      Representation representation,
+      const FieldGuardState& field_guard_state = FieldGuardState());
+
   // There is a fixed statically known number of native slots so we cache
   // them statically.
   static AcqRelAtomic<Slot*> native_fields_;
diff --git a/runtime/vm/compiler/compiler_pass.cc b/runtime/vm/compiler/compiler_pass.cc
index f6a4dd3..6486fca 100644
--- a/runtime/vm/compiler/compiler_pass.cc
+++ b/runtime/vm/compiler/compiler_pass.cc
@@ -84,6 +84,7 @@
                       "Do --compiler-passes=help for more information.");
 DECLARE_FLAG(bool, print_flow_graph);
 DECLARE_FLAG(bool, print_flow_graph_optimized);
+DEFINE_FLAG(bool, test_il_serialization, false, "Test IL serialization.");
 
 void CompilerPassState::set_flow_graph(FlowGraph* flow_graph) {
   flow_graph_ = flow_graph;
@@ -565,6 +566,22 @@
   if (state->reorder_blocks) {
     BlockScheduler::ReorderBlocks(flow_graph);
   }
+
+  // This is the last compiler pass.
+  // Test that round-trip IL serialization works before generating code.
+  if (FLAG_test_il_serialization && CompilerState::Current().is_aot()) {
+    Zone* zone = flow_graph->zone();
+    auto* detached_defs = new (zone) ZoneGrowableArray<Definition*>(zone, 0);
+    flow_graph->CompactSSA(detached_defs);
+
+    ZoneWriteStream write_stream(flow_graph->zone(), 1024);
+    FlowGraphSerializer serializer(&write_stream);
+    serializer.WriteFlowGraph(*flow_graph, *detached_defs);
+    ReadStream read_stream(write_stream.buffer(), write_stream.bytes_written());
+    FlowGraphDeserializer deserializer(flow_graph->parsed_function(),
+                                       &read_stream);
+    state->set_flow_graph(deserializer.ReadFlowGraph());
+  }
 });
 
 COMPILER_PASS(EliminateWriteBarriers, { EliminateWriteBarriers(flow_graph); });
diff --git a/runtime/vm/compiler/compiler_sources.gni b/runtime/vm/compiler/compiler_sources.gni
index ace9914..ed545d6 100644
--- a/runtime/vm/compiler/compiler_sources.gni
+++ b/runtime/vm/compiler/compiler_sources.gni
@@ -65,6 +65,8 @@
   "backend/il_printer.cc",
   "backend/il_printer.h",
   "backend/il_riscv.cc",
+  "backend/il_serializer.cc",
+  "backend/il_serializer.h",
   "backend/il_x64.cc",
   "backend/inliner.cc",
   "backend/inliner.h",
diff --git a/runtime/vm/compiler/ffi/call.cc b/runtime/vm/compiler/ffi/call.cc
index be76d75..0cee4de 100644
--- a/runtime/vm/compiler/ffi/call.cc
+++ b/runtime/vm/compiler/ffi/call.cc
@@ -14,18 +14,15 @@
 namespace ffi {
 
 // TODO(dartbug.com/36607): Cache the trampolines.
-FunctionPtr TrampolineFunction(const FunctionType& dart_signature,
+FunctionPtr TrampolineFunction(const String& name,
+                               const FunctionType& signature,
                                const FunctionType& c_signature,
-                               bool is_leaf,
-                               const String& function_name) {
+                               bool is_leaf) {
+  ASSERT(signature.num_implicit_parameters() == 1);
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
-  String& name =
-      String::Handle(zone, Symbols::NewFormatted(thread, "FfiTrampoline_%s",
-                                                 function_name.ToCString()));
   const Library& lib = Library::Handle(zone, Library::FfiLibrary());
   const Class& owner_class = Class::Handle(zone, lib.toplevel_class());
-  FunctionType& signature = FunctionType::Handle(zone, FunctionType::New());
   Function& function = Function::Handle(
       zone, Function::New(signature, name, UntaggedFunction::kFfiTrampoline,
                           /*is_static=*/true,
@@ -35,31 +32,47 @@
                           /*is_native=*/false, owner_class,
                           TokenPosition::kMinSource));
   function.set_is_debuggable(false);
+
+  // Create unique names for the parameters, as they are used in scope building
+  // and error messages.
+  if (signature.num_fixed_parameters() > 0) {
+    function.CreateNameArray();
+    function.SetParameterNameAt(0, Symbols::ClosureParameter());
+    auto& param_name = String::Handle(zone);
+    for (intptr_t i = 1, n = signature.num_fixed_parameters(); i < n; ++i) {
+      param_name = Symbols::NewFormatted(thread, ":ffi_param%" Pd, i);
+      function.SetParameterNameAt(i, param_name);
+    }
+  }
+
+  function.SetFfiCSignature(c_signature);
+  function.SetFfiIsLeaf(is_leaf);
+
+  return function.ptr();
+}
+
+FunctionPtr TrampolineFunction(const FunctionType& dart_signature,
+                               const FunctionType& c_signature,
+                               bool is_leaf,
+                               const String& function_name) {
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  String& name =
+      String::Handle(zone, Symbols::NewFormatted(thread, "FfiTrampoline_%s",
+                                                 function_name.ToCString()));
+
   // Trampolines have no optional arguments.
+  FunctionType& signature = FunctionType::Handle(zone, FunctionType::New());
   const intptr_t num_fixed = dart_signature.num_fixed_parameters();
+  signature.set_num_implicit_parameters(1);
   signature.set_num_fixed_parameters(num_fixed);
   signature.set_result_type(
       AbstractType::Handle(zone, dart_signature.result_type()));
   signature.set_parameter_types(
       Array::Handle(zone, dart_signature.parameter_types()));
-
-  // Create unique names for the parameters, as they are used in scope building
-  // and error messages.
-  if (num_fixed > 0) {
-    function.CreateNameArray();
-    function.SetParameterNameAt(0, Symbols::ClosureParameter());
-    for (intptr_t i = 1; i < num_fixed; i++) {
-      name = Symbols::NewFormatted(thread, ":ffi_param%" Pd, i);
-      function.SetParameterNameAt(i, name);
-    }
-  }
-  function.SetFfiCSignature(c_signature);
   signature ^= ClassFinalizer::FinalizeType(signature);
-  function.SetSignature(signature);
 
-  function.SetFfiIsLeaf(is_leaf);
-
-  return function.ptr();
+  return TrampolineFunction(name, signature, c_signature, is_leaf);
 }
 
 }  // namespace ffi
diff --git a/runtime/vm/compiler/ffi/call.h b/runtime/vm/compiler/ffi/call.h
index aecd128..11c328a 100644
--- a/runtime/vm/compiler/ffi/call.h
+++ b/runtime/vm/compiler/ffi/call.h
@@ -19,6 +19,11 @@
 
 namespace ffi {
 
+FunctionPtr TrampolineFunction(const String& name,
+                               const FunctionType& signature,
+                               const FunctionType& c_signature,
+                               bool is_leaf);
+
 FunctionPtr TrampolineFunction(const FunctionType& dart_signature,
                                const FunctionType& c_signature,
                                bool is_leaf,
diff --git a/runtime/vm/compiler/ffi/marshaller.h b/runtime/vm/compiler/ffi/marshaller.h
index 175e12e..61eea68 100644
--- a/runtime/vm/compiler/ffi/marshaller.h
+++ b/runtime/vm/compiler/ffi/marshaller.h
@@ -131,6 +131,7 @@
 
   bool ContainsHandles() const;
 
+  const Function& dart_signature() const { return dart_signature_; }
   StringPtr function_name() const { return dart_signature_.name(); }
 
  protected:
diff --git a/runtime/vm/compiler/stub_code_compiler.cc b/runtime/vm/compiler/stub_code_compiler.cc
index 525dc4d..a4c1c5e 100644
--- a/runtime/vm/compiler/stub_code_compiler.cc
+++ b/runtime/vm/compiler/stub_code_compiler.cc
@@ -889,7 +889,8 @@
   // Fall through to &is_simple_case
 
   const RegisterSet caller_saved_registers(
-      TypeTestABI::kSubtypeTestCacheStubCallerSavedRegisters);
+      TypeTestABI::kSubtypeTestCacheStubCallerSavedRegisters,
+      /*fpu_registers=*/0);
 
   __ Bind(&is_simple_case);
   {
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 76817ed..0aca34f 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -3222,6 +3222,28 @@
   }
 }
 
+intptr_t Class::FindFunctionIndex(const Function& needle) const {
+  Thread* thread = Thread::Current();
+  if (EnsureIsFinalized(thread) != Error::null()) {
+    return -1;
+  }
+  REUSABLE_ARRAY_HANDLESCOPE(thread);
+  REUSABLE_FUNCTION_HANDLESCOPE(thread);
+  Array& funcs = thread->ArrayHandle();
+  Function& function = thread->FunctionHandle();
+  funcs = current_functions();
+  ASSERT(!funcs.IsNull());
+  const intptr_t len = funcs.Length();
+  for (intptr_t i = 0; i < len; i++) {
+    function ^= funcs.At(i);
+    if (needle.ptr() == function.ptr()) {
+      return i;
+    }
+  }
+  // No function found.
+  return -1;
+}
+
 FunctionPtr Class::FunctionFromIndex(intptr_t idx) const {
   const Array& funcs = Array::Handle(current_functions());
   if ((idx < 0) || (idx >= funcs.Length())) {
@@ -3234,20 +3256,13 @@
 }
 
 FunctionPtr Class::ImplicitClosureFunctionFromIndex(intptr_t idx) const {
-  const Array& funcs = Array::Handle(current_functions());
-  if ((idx < 0) || (idx >= funcs.Length())) {
+  Function& func = Function::Handle(FunctionFromIndex(idx));
+  if (func.IsNull() || !func.HasImplicitClosureFunction()) {
     return Function::null();
   }
-  Function& func = Function::Handle();
-  func ^= funcs.At(idx);
+  func = func.ImplicitClosureFunction();
   ASSERT(!func.IsNull());
-  if (!func.HasImplicitClosureFunction()) {
-    return Function::null();
-  }
-  const Function& closure_func =
-      Function::Handle(func.ImplicitClosureFunction());
-  ASSERT(!closure_func.IsNull());
-  return closure_func.ptr();
+  return func.ptr();
 }
 
 intptr_t Class::FindImplicitClosureFunctionIndex(const Function& needle) const {
@@ -4682,6 +4697,35 @@
   SetFields(new_arr);
 }
 
+intptr_t Class::FindFieldIndex(const Field& needle) const {
+  Thread* thread = Thread::Current();
+  if (EnsureIsFinalized(thread) != Error::null()) {
+    return -1;
+  }
+  REUSABLE_ARRAY_HANDLESCOPE(thread);
+  REUSABLE_FIELD_HANDLESCOPE(thread);
+  Array& fields = thread->ArrayHandle();
+  Field& field = thread->FieldHandle();
+  fields = this->fields();
+  ASSERT(!fields.IsNull());
+  for (intptr_t i = 0, n = fields.Length(); i < n; ++i) {
+    field ^= fields.At(i);
+    if (needle.ptr() == field.ptr()) {
+      return i;
+    }
+  }
+  // Not found.
+  return -1;
+}
+
+FieldPtr Class::FieldFromIndex(intptr_t idx) const {
+  Array& fields = Array::Handle(this->fields());
+  if ((idx < 0) || (idx >= fields.Length())) {
+    return Field::null();
+  }
+  return Field::RawCast(fields.At(idx));
+}
+
 bool Class::InjectCIDFields() const {
   if (library() != Library::InternalLibrary() ||
       Name() != Symbols::ClassID().ptr()) {
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index ed7f206..555d22c 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -1478,6 +1478,9 @@
   void AddField(const Field& field) const;
   void AddFields(const GrowableArray<const Field*>& fields) const;
 
+  intptr_t FindFieldIndex(const Field& needle) const;
+  FieldPtr FieldFromIndex(intptr_t idx) const;
+
   // If this is a dart:internal.ClassID class, then inject our own const
   // fields. Returns true if synthetic fields are injected and regular
   // field declarations should be ignored.
@@ -1505,6 +1508,7 @@
   }
   void SetFunctions(const Array& value) const;
   void AddFunction(const Function& function) const;
+  intptr_t FindFunctionIndex(const Function& needle) const;
   FunctionPtr FunctionFromIndex(intptr_t idx) const;
   intptr_t FindImplicitClosureFunctionIndex(const Function& needle) const;
   FunctionPtr ImplicitClosureFunctionFromIndex(intptr_t idx) const;
@@ -7772,6 +7776,8 @@
   friend class Closure;
   friend class Pointer;
   friend class DeferredObject;
+  friend class FlowGraphSerializer;
+  friend class FlowGraphDeserializer;
   friend class RegExp;
   friend class StubCode;
   friend class TypedDataView;
@@ -7898,6 +7904,8 @@
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeParameters, Object);
   friend class Class;
   friend class ClassFinalizer;
+  friend class FlowGraphSerializer;
+  friend class FlowGraphDeserializer;
   friend class Function;
   friend class FunctionType;
   friend class Object;
@@ -9911,6 +9919,7 @@
 
   friend class Class;
   friend class ExternalOneByteString;
+  friend class FlowGraphSerializer;
   friend class ImageWriter;
   friend class String;
   friend class StringHasher;
@@ -10031,6 +10040,7 @@
   }
 
   friend class Class;
+  friend class FlowGraphSerializer;
   friend class ImageWriter;
   friend class String;
   friend class StringHasher;
diff --git a/runtime/vm/regexp_assembler_ir.cc b/runtime/vm/regexp_assembler_ir.cc
index 2e7a7b4..99440a2 100644
--- a/runtime/vm/regexp_assembler_ir.cc
+++ b/runtime/vm/regexp_assembler_ir.cc
@@ -928,15 +928,9 @@
 
     Definition* is_match_def;
 
-    if (unicode) {
-      is_match_def = new (Z) CaseInsensitiveCompareInstr(
-          string_value, lhs_index_value, rhs_index_value, length_value,
-          kCaseInsensitiveCompareUTF16RuntimeEntry, specialization_cid_);
-    } else {
-      is_match_def = new (Z) CaseInsensitiveCompareInstr(
-          string_value, lhs_index_value, rhs_index_value, length_value,
-          kCaseInsensitiveCompareUCS2RuntimeEntry, specialization_cid_);
-    }
+    is_match_def = new (Z) CaseInsensitiveCompareInstr(
+        string_value, lhs_index_value, rhs_index_value, length_value,
+        /*handle_surrogates=*/unicode, specialization_cid_);
 
     BranchOrBacktrack(Comparison(kNE, is_match_def, BoolConstant(true)),
                       on_no_match);
diff --git a/runtime/vm/type_testing_stubs.cc b/runtime/vm/type_testing_stubs.cc
index 41ac9d1..aa79b1d 100644
--- a/runtime/vm/type_testing_stubs.cc
+++ b/runtime/vm/type_testing_stubs.cc
@@ -626,7 +626,7 @@
     // c) Then we'll check each value of the type argument.
     compiler::Label pop_saved_registers_on_failure;
     const RegisterSet saved_registers(
-        TTSInternalRegs::kSavedTypeArgumentRegisters);
+        TTSInternalRegs::kSavedTypeArgumentRegisters, /*fpu_registers=*/0);
     __ PushRegisters(saved_registers);
 
     AbstractType& type_arg = AbstractType::Handle();