Exclude clustered snapshot writer from AOT runtime.

runtime/vm/clustered_snapshot.cc

 // Copyright (c) 2016, 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/clustered_snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 31 matching lines @@
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   uword tags = 0;
   tags = RawObject::ClassIdTag::update(class_id, tags);
   tags = RawObject::SizeTag::update(size, tags);
   tags = RawObject::VMHeapObjectTag::update(is_vm_isolate, tags);
   tags = RawObject::CanonicalObjectTag::update(is_canonical, tags);
   raw->ptr()->tags_ = tags;
 }
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class ClassSerializationCluster : public SerializationCluster {
  public:
   explicit ClassSerializationCluster(intptr_t num_cids) :
       predefined_(kNumPredefinedCids), objects_(num_cids) { }
   virtual ~ClassSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawClass* cls = Class::RawCast(object);
     intptr_t class_id = cls->ptr()->id_;
 
@@ skipping 58 matching lines @@
     s->Write<uint16_t>(cls->ptr()->num_own_type_arguments_);
     s->Write<uint16_t>(cls->ptr()->num_native_fields_);
     s->WriteTokenPosition(cls->ptr()->token_pos_);
     s->Write<uint16_t>(cls->ptr()->state_bits_);
   }
 
  private:
   GrowableArray<RawClass*> predefined_;
   GrowableArray<RawClass*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class ClassDeserializationCluster : public DeserializationCluster {
  public:
   ClassDeserializationCluster() { }
   virtual ~ClassDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     predefined_start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 100 matching lines @@
       cls.RehashConstants(zone);
     }
   }
 
  private:
   intptr_t predefined_start_index_;
   intptr_t predefined_stop_index_;
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class UnresolvedClassSerializationCluster : public SerializationCluster {
  public:
   UnresolvedClassSerializationCluster() { }
   virtual ~UnresolvedClassSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawUnresolvedClass* cls = UnresolvedClass::RawCast(object);
     objects_.Add(cls);
 
     RawObject** from = cls->from();
@@ skipping 23 matching lines @@
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
       s->WriteTokenPosition(cls->ptr()->token_pos_);
     }
   }
 
  private:
   GrowableArray<RawUnresolvedClass*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class UnresolvedClassDeserializationCluster : public DeserializationCluster {
  public:
   UnresolvedClassDeserializationCluster() { }
   virtual ~UnresolvedClassDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 18 matching lines @@
       RawObject** to = cls->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
       cls->ptr()->token_pos_ = d->ReadTokenPosition();
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class TypeArgumentsSerializationCluster : public SerializationCluster {
  public:
   TypeArgumentsSerializationCluster() { }
   virtual ~TypeArgumentsSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawTypeArguments* type_args = TypeArguments::RawCast(object);
     objects_.Add(type_args);
 
     s->Push(type_args->ptr()->instantiations_);
@@ skipping 27 matching lines @@
       s->WriteRef(type_args->ptr()->instantiations_);
       for (intptr_t j = 0; j < length; j++) {
         s->WriteRef(type_args->ptr()->types()[j]);
       }
     }
   }
 
  private:
   GrowableArray<RawTypeArguments*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class TypeArgumentsDeserializationCluster : public DeserializationCluster {
  public:
   TypeArgumentsDeserializationCluster() { }
   virtual ~TypeArgumentsDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 23 matching lines @@
           reinterpret_cast<RawArray*>(d->ReadRef());
       for (intptr_t j = 0; j < length; j++) {
         type_args->ptr()->types()[j] =
             reinterpret_cast<RawAbstractType*>(d->ReadRef());
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class PatchClassSerializationCluster : public SerializationCluster {
  public:
   PatchClassSerializationCluster() { }
   virtual ~PatchClassSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawPatchClass* cls = PatchClass::RawCast(object);
     objects_.Add(cls);
 
     RawObject** from = cls->from();
@@ skipping 21 matching lines @@
       RawObject** to = cls->to();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawPatchClass*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class PatchClassDeserializationCluster : public DeserializationCluster {
  public:
   PatchClassDeserializationCluster() { }
   virtual ~PatchClassDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 15 matching lines @@
       RawObject** from = cls->from();
       RawObject** to = cls->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class FunctionSerializationCluster : public SerializationCluster {
  public:
   FunctionSerializationCluster() { }
   virtual ~FunctionSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawFunction* func = Function::RawCast(object);
     objects_.Add(func);
 
     RawObject** from = func->from();
@@ skipping 53 matching lines @@
         s->Write<int8_t>(func->ptr()->deoptimization_counter_);
         s->Write<uint16_t>(func->ptr()->optimized_instruction_count_);
         s->Write<uint16_t>(func->ptr()->optimized_call_site_count_);
       }
     }
   }
 
  private:
   GrowableArray<RawFunction*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class FunctionDeserializationCluster : public DeserializationCluster {
  public:
   FunctionDeserializationCluster() { }
   virtual ~FunctionDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 83 matching lines @@
         func ^= refs.At(i);
         func.ClearICDataArray();
         func.ClearCode();
         func.set_was_compiled(false);
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class ClosureDataSerializationCluster : public SerializationCluster {
  public:
   ClosureDataSerializationCluster() { }
   virtual ~ClosureDataSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawClosureData* data = ClosureData::RawCast(object);
     objects_.Add(data);
 
     RawObject** from = data->from();
@@ skipping 21 matching lines @@
       RawObject** to = data->to();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawClosureData*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class ClosureDataDeserializationCluster : public DeserializationCluster {
  public:
   ClosureDataDeserializationCluster() { }
   virtual ~ClosureDataDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 15 matching lines @@
       RawObject** from = data->from();
       RawObject** to = data->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class RedirectionDataSerializationCluster : public SerializationCluster {
  public:
   RedirectionDataSerializationCluster() { }
   virtual ~RedirectionDataSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawRedirectionData* data = RedirectionData::RawCast(object);
     objects_.Add(data);
 
     RawObject** from = data->from();
@@ skipping 21 matching lines @@
       RawObject** to = data->to();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawRedirectionData*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class RedirectionDataDeserializationCluster : public DeserializationCluster {
  public:
   RedirectionDataDeserializationCluster() { }
   virtual ~RedirectionDataDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 17 matching lines @@
       RawObject** from = data->from();
       RawObject** to = data->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class FieldSerializationCluster : public SerializationCluster {
  public:
   FieldSerializationCluster() { }
   virtual ~FieldSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawField* field = Field::RawCast(object);
     objects_.Add(field);
 
     Snapshot::Kind kind = s->kind();
@@ skipping 80 matching lines @@
         s->WriteCid(field->ptr()->guarded_cid_);
         s->WriteCid(field->ptr()->is_nullable_);
       }
       s->Write<uint8_t>(field->ptr()->kind_bits_);
     }
   }
 
  private:
   GrowableArray<RawField*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class FieldDeserializationCluster : public DeserializationCluster {
  public:
   FieldDeserializationCluster() { }
   virtual ~FieldDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 48 matching lines @@
     } else {
       for (intptr_t i = start_index_; i < stop_index_; i++) {
         field ^= refs.At(i);
         field.InitializeGuardedListLengthInObjectOffset();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class LiteralTokenSerializationCluster : public SerializationCluster {
  public:
   LiteralTokenSerializationCluster() { }
   virtual ~LiteralTokenSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawLiteralToken* token = LiteralToken::RawCast(object);
     objects_.Add(token);
 
     RawObject** from = token->from();
@@ skipping 22 matching lines @@
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
       s->Write<int32_t>(token->ptr()->kind_);
     }
   }
 
  private:
   GrowableArray<RawLiteralToken*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class LiteralTokenDeserializationCluster : public DeserializationCluster {
  public:
   LiteralTokenDeserializationCluster() { }
   virtual ~LiteralTokenDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 17 matching lines @@
       RawObject** to = token->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
       token->ptr()->kind_ = static_cast<Token::Kind>(d->Read<int32_t>());
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class TokenStreamSerializationCluster : public SerializationCluster {
  public:
   TokenStreamSerializationCluster() { }
   virtual ~TokenStreamSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawTokenStream* stream = TokenStream::RawCast(object);
     objects_.Add(stream);
 
     RawObject** from = stream->from();
@@ skipping 21 matching lines @@
       RawObject** to = stream->to();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawTokenStream*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class TokenStreamDeserializationCluster : public DeserializationCluster {
  public:
   TokenStreamDeserializationCluster() { }
   virtual ~TokenStreamDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 15 matching lines @@
       RawObject** from = stream->from();
       RawObject** to = stream->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class ScriptSerializationCluster : public SerializationCluster {
  public:
   ScriptSerializationCluster() { }
   virtual ~ScriptSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawScript* script = Script::RawCast(object);
     objects_.Add(script);
 
     RawObject** from = script->from();
@@ skipping 26 matching lines @@
 
       s->Write<int32_t>(script->ptr()->line_offset_);
       s->Write<int32_t>(script->ptr()->col_offset_);
       s->Write<int8_t>(script->ptr()->kind_);
     }
   }
 
  private:
   GrowableArray<RawScript*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class ScriptDeserializationCluster : public DeserializationCluster {
  public:
   ScriptDeserializationCluster() { }
   virtual ~ScriptDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 24 matching lines @@
 
       script->ptr()->line_offset_ = d->Read<int32_t>();
       script->ptr()->col_offset_ = d->Read<int32_t>();
       script->ptr()->kind_ = d->Read<int8_t>();
       script->ptr()->load_timestamp_ = 0;
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class LibrarySerializationCluster : public SerializationCluster {
  public:
   LibrarySerializationCluster() { }
   virtual ~LibrarySerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawLibrary* lib = Library::RawCast(object);
     objects_.Add(lib);
 
     RawObject** from = lib->from();
@@ skipping 28 matching lines @@
       s->Write<int8_t>(lib->ptr()->load_state_);
       s->Write<bool>(lib->ptr()->corelib_imported_);
       s->Write<bool>(lib->ptr()->is_dart_scheme_);
       s->Write<bool>(lib->ptr()->debuggable_);
     }
   }
 
  private:
   GrowableArray<RawLibrary*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
+
 
 class LibraryDeserializationCluster : public DeserializationCluster {
  public:
   LibraryDeserializationCluster() { }
   virtual ~LibraryDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
@@ skipping 42 matching lines @@
     Library& lib = Library::Handle(zone);
     for (intptr_t i = start_index_; i < stop_index_; i++) {
       lib ^= refs.At(i);
       const intptr_t kInitialNameCacheSize = 64;
       lib.InitResolvedNamesCache(kInitialNameCacheSize);
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class NamespaceSerializationCluster : public SerializationCluster {
  public:
   NamespaceSerializationCluster() { }
   virtual ~NamespaceSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawNamespace* ns = Namespace::RawCast(object);
     objects_.Add(ns);
 
     RawObject** from = ns->from();
@@ skipping 21 matching lines @@
       RawObject** to = ns->to();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawNamespace*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class NamespaceDeserializationCluster : public DeserializationCluster {
  public:
   NamespaceDeserializationCluster() { }
   virtual ~NamespaceDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 14 matching lines @@
       RawObject** from = ns->from();
       RawObject** to = ns->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class CodeSerializationCluster : public SerializationCluster {
  public:
   CodeSerializationCluster() { }
   virtual ~CodeSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawCode* code = Code::RawCast(object);
     objects_.Add(code);
 
     s->Push(code->ptr()->object_pool_);
@@ skipping 49 matching lines @@
       s->WriteRef(code->ptr()->pc_descriptors_);
       s->WriteRef(code->ptr()->stackmaps_);
 
       s->Write<int32_t>(code->ptr()->state_bits_);
     }
   }
 
  private:
   GrowableArray<RawCode*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class CodeDeserializationCluster : public DeserializationCluster {
  public:
   CodeDeserializationCluster() { }
   virtual ~CodeDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 40 matching lines @@
       code->ptr()->return_address_metadata_ = Object::null();
 
       code->ptr()->compile_timestamp_ = 0;
       code->ptr()->state_bits_ = d->Read<int32_t>();
       code->ptr()->lazy_deopt_pc_offset_ = -1;
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class ObjectPoolSerializationCluster : public SerializationCluster {
  public:
   ObjectPoolSerializationCluster() { }
   virtual ~ObjectPoolSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawObjectPool* pool = ObjectPool::RawCast(object);
     objects_.Add(pool);
 
     intptr_t length = pool->ptr()->length_;
@@ skipping 63 matching lines @@
         default:
           UNREACHABLE();
         }
       }
     }
   }
 
  private:
   GrowableArray<RawObjectPool*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class ObjectPoolDeserializationCluster : public DeserializationCluster {
  public:
   ObjectPoolDeserializationCluster() { }
   virtual ~ObjectPoolDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 47 matching lines @@
           }
           default:
             UNREACHABLE();
         }
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 // PcDescriptor, Stackmap, OneByteString, TwoByteString
 class RODataSerializationCluster : public SerializationCluster {
  public:
   explicit RODataSerializationCluster(intptr_t cid) : cid_(cid) { }
   virtual ~RODataSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     objects_.Add(object);
 
     // A string's hash must already be computed when we write it because it
@@ skipping 30 matching lines @@
   }
 
   void WriteFill(Serializer* s) {
     // No-op.
   }
 
  private:
   const intptr_t cid_;
   GrowableArray<RawObject*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class RODataDeserializationCluster : public DeserializationCluster {
  public:
   RODataDeserializationCluster() { }
   virtual ~RODataDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       int32_t rodata_offset = d->Read<int32_t>();
       d->AssignRef(d->GetObjectAt(rodata_offset));
     }
   }
 
   void ReadFill(Deserializer* d) {
     // No-op.
   }
 };
 
 
-class LocalVarDescriptorsSerializationCluster : public SerializationCluster {
- public:
-  LocalVarDescriptorsSerializationCluster() { }
-  virtual ~LocalVarDescriptorsSerializationCluster() { }
-
-  void Trace(Serializer* s, RawObject* object) { UNIMPLEMENTED(); }
-  void WriteAlloc(Serializer* s) {}
-  void WriteFill(Serializer* s) {}
-
- private:
-  GrowableArray<RawClass*> objects_;
-};
-
-
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class ExceptionHandlersSerializationCluster : public SerializationCluster {
  public:
   ExceptionHandlersSerializationCluster() { }
   virtual ~ExceptionHandlersSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawExceptionHandlers* handlers = ExceptionHandlers::RawCast(object);
     objects_.Add(handlers);
 
     s->Push(handlers->ptr()->handled_types_data_);
@@ skipping 22 matching lines @@
       uint8_t* data = reinterpret_cast<uint8_t*>(handlers->ptr()->data());
       intptr_t length_in_bytes =
           length * sizeof(RawExceptionHandlers::HandlerInfo);
       s->WriteBytes(data, length_in_bytes);
     }
   }
 
  private:
   GrowableArray<RawExceptionHandlers*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class ExceptionHandlersDeserializationCluster : public DeserializationCluster {
  public:
   ExceptionHandlersDeserializationCluster() { }
   virtual ~ExceptionHandlersDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 21 matching lines @@
           reinterpret_cast<RawArray*>(d->ReadRef());
 
       uint8_t* data = reinterpret_cast<uint8_t*>(handlers->ptr()->data());
       intptr_t length_in_bytes =
           length * sizeof(RawExceptionHandlers::HandlerInfo);
       d->ReadBytes(data, length_in_bytes);
     }
   }
 };
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class ContextSerializationCluster : public SerializationCluster {
  public:
   ContextSerializationCluster() { }
   virtual ~ContextSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawContext* context = Context::RawCast(object);
     objects_.Add(context);
 
     s->Push(context->ptr()->parent_);
@@ skipping 24 matching lines @@
       s->WriteRef(context->ptr()->parent_);
       for (intptr_t j = 0; j < length; j++) {
         s->WriteRef(context->ptr()->data()[j]);
       }
     }
   }
 
  private:
   GrowableArray<RawContext*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class ContextDeserializationCluster : public DeserializationCluster {
  public:
   ContextDeserializationCluster() { }
   virtual ~ContextDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 18 matching lines @@
       context->ptr()->num_variables_ = length;
       context->ptr()->parent_ = reinterpret_cast<RawContext*>(d->ReadRef());
       for (intptr_t j = 0; j < length; j++) {
         context->ptr()->data()[j] = d->ReadRef();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class ContextScopeSerializationCluster : public SerializationCluster {
  public:
   ContextScopeSerializationCluster() { }
   virtual ~ContextScopeSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawContextScope* scope = ContextScope::RawCast(object);
     objects_.Add(scope);
 
     intptr_t length = scope->ptr()->num_variables_;
@@ skipping 27 matching lines @@
       RawObject** to = scope->to(length);
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawContextScope*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class ContextScopeDeserializationCluster : public DeserializationCluster {
  public:
   ContextScopeDeserializationCluster() { }
   virtual ~ContextScopeDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 20 matching lines @@
       RawObject** from = scope->from();
       RawObject** to = scope->to(length);
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class ICDataSerializationCluster : public SerializationCluster {
  public:
   ICDataSerializationCluster() { }
   virtual ~ICDataSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawICData* ic = ICData::RawCast(object);
     objects_.Add(ic);
 
     RawObject** from = ic->from();
@@ skipping 27 matching lines @@
       s->Write<uint32_t>(ic->ptr()->state_bits_);
 #if defined(TAG_IC_DATA)
       s->Write<int32_t>(ic->ptr()->tag_);
 #endif
     }
   }
 
  private:
   GrowableArray<RawICData*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class ICDataDeserializationCluster : public DeserializationCluster {
  public:
   ICDataDeserializationCluster() { }
   virtual ~ICDataDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 24 matching lines @@
       ic->ptr()->deopt_id_ = d->Read<int32_t>();
       ic->ptr()->state_bits_ = d->Read<int32_t>();
 #if defined(TAG_IC_DATA)
       ic->ptr()->tag_ = d->Read<int32_t>();
 #endif
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class MegamorphicCacheSerializationCluster : public SerializationCluster {
  public:
   MegamorphicCacheSerializationCluster() { }
   virtual ~MegamorphicCacheSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawMegamorphicCache* cache = MegamorphicCache::RawCast(object);
     objects_.Add(cache);
 
     RawObject** from = cache->from();
@@ skipping 22 matching lines @@
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
       s->Write<int32_t>(cache->ptr()->filled_entry_count_);
     }
   }
 
  private:
   GrowableArray<RawMegamorphicCache*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class MegamorphicCacheDeserializationCluster : public DeserializationCluster {
  public:
   MegamorphicCacheDeserializationCluster() { }
   virtual ~MegamorphicCacheDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 18 matching lines @@
       RawObject** to = cache->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
       cache->ptr()->filled_entry_count_ = d->Read<int32_t>();
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class SubtypeTestCacheSerializationCluster : public SerializationCluster {
  public:
   SubtypeTestCacheSerializationCluster() { }
   virtual ~SubtypeTestCacheSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawSubtypeTestCache* cache = SubtypeTestCache::RawCast(object);
     objects_.Add(cache);
     s->Push(cache->ptr()->cache_);
   }
@@ skipping 12 matching lines @@
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawSubtypeTestCache* cache = objects_[i];
       s->WriteRef(cache->ptr()->cache_);
     }
   }
 
  private:
   GrowableArray<RawSubtypeTestCache*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class SubtypeTestCacheDeserializationCluster : public DeserializationCluster {
  public:
   SubtypeTestCacheDeserializationCluster() { }
   virtual ~SubtypeTestCacheDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 13 matching lines @@
           reinterpret_cast<RawSubtypeTestCache*>(d->Ref(id));
       Deserializer::InitializeHeader(cache, kSubtypeTestCacheCid,
                                      SubtypeTestCache::InstanceSize(),
                                      is_vm_object);
       cache->ptr()->cache_ = reinterpret_cast<RawArray*>(d->ReadRef());
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class LanguageErrorSerializationCluster : public SerializationCluster {
  public:
   LanguageErrorSerializationCluster() { }
   virtual ~LanguageErrorSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawLanguageError* error = LanguageError::RawCast(object);
     objects_.Add(error);
 
     RawObject** from = error->from();
@@ skipping 24 matching lines @@
       }
       s->WriteTokenPosition(error->ptr()->token_pos_);
       s->Write<bool>(error->ptr()->report_after_token_);
       s->Write<int8_t>(error->ptr()->kind_);
     }
   }
 
  private:
   GrowableArray<RawLanguageError*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class LanguageErrorDeserializationCluster : public DeserializationCluster {
  public:
   LanguageErrorDeserializationCluster() { }
   virtual ~LanguageErrorDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 19 matching lines @@
         *p = d->ReadRef();
       }
       error->ptr()->token_pos_ = d->ReadTokenPosition();
       error->ptr()->report_after_token_ = d->Read<bool>();
       error->ptr()->kind_ = d->Read<int8_t>();
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class UnhandledExceptionSerializationCluster : public SerializationCluster {
  public:
   UnhandledExceptionSerializationCluster() { }
   virtual ~UnhandledExceptionSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawUnhandledException* exception = UnhandledException::RawCast(object);
     objects_.Add(exception);
 
     RawObject** from = exception->from();
@@ skipping 21 matching lines @@
       RawObject** to = exception->to();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawUnhandledException*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class UnhandledExceptionDeserializationCluster : public DeserializationCluster {
  public:
   UnhandledExceptionDeserializationCluster() { }
   virtual ~UnhandledExceptionDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 17 matching lines @@
       RawObject** from = exception->from();
       RawObject** to = exception->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class InstanceSerializationCluster : public SerializationCluster {
  public:
   explicit InstanceSerializationCluster(intptr_t cid) : cid_(cid) {
     RawClass* cls = Isolate::Current()->class_table()->At(cid);
     next_field_offset_in_words_ = cls->ptr()->next_field_offset_in_words_;
     instance_size_in_words_ = cls->ptr()->instance_size_in_words_;
     ASSERT(next_field_offset_in_words_ > 0);
     ASSERT(instance_size_in_words_ > 0);
   }
   virtual ~InstanceSerializationCluster() { }
@@ skipping 41 matching lines @@
       }
     }
   }
 
  private:
   const intptr_t cid_;
   intptr_t next_field_offset_in_words_;
   intptr_t instance_size_in_words_;
   GrowableArray<RawInstance*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class InstanceDeserializationCluster : public DeserializationCluster {
  public:
   explicit InstanceDeserializationCluster(intptr_t cid) : cid_(cid) { }
   virtual ~InstanceDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 37 matching lines @@
     }
   }
 
  private:
   const intptr_t cid_;
   intptr_t next_field_offset_in_words_;
   intptr_t instance_size_in_words_;
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class LibraryPrefixSerializationCluster : public SerializationCluster {
  public:
   LibraryPrefixSerializationCluster() { }
   virtual ~LibraryPrefixSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawLibraryPrefix* prefix = LibraryPrefix::RawCast(object);
     objects_.Add(prefix);
 
     RawObject** from = prefix->from();
@@ skipping 24 matching lines @@
       }
       s->Write<uint16_t>(prefix->ptr()->num_imports_);
       s->Write<bool>(prefix->ptr()->is_deferred_load_);
       s->Write<bool>(prefix->ptr()->is_loaded_);
     }
   }
 
  private:
   GrowableArray<RawLibraryPrefix*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class LibraryPrefixDeserializationCluster : public DeserializationCluster {
  public:
   LibraryPrefixDeserializationCluster() { }
   virtual ~LibraryPrefixDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 20 matching lines @@
         *p = d->ReadRef();
       }
       prefix->ptr()->num_imports_ = d->Read<uint16_t>();
       prefix->ptr()->is_deferred_load_ = d->Read<bool>();
       prefix->ptr()->is_loaded_ = d->Read<bool>();
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class TypeSerializationCluster : public SerializationCluster {
  public:
   TypeSerializationCluster() { }
   virtual ~TypeSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawType* type = Type::RawCast(object);
     if (type->IsCanonical()) {
       canonical_objects_.Add(type);
     } else {
@@ skipping 50 matching lines @@
       }
       s->WriteTokenPosition(type->ptr()->token_pos_);
       s->Write<int8_t>(type->ptr()->type_state_);
     }
   }
 
  private:
   GrowableArray<RawType*> canonical_objects_;
   GrowableArray<RawType*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class TypeDeserializationCluster : public DeserializationCluster {
  public:
   TypeDeserializationCluster() { }
   virtual ~TypeDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     canonical_start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 42 matching lines @@
       type->ptr()->type_state_ = d->Read<int8_t>();
     }
   }
 
  private:
   intptr_t canonical_start_index_;
   intptr_t canonical_stop_index_;
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class TypeRefSerializationCluster : public SerializationCluster {
  public:
   TypeRefSerializationCluster() { }
   virtual ~TypeRefSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawTypeRef* type = TypeRef::RawCast(object);
     objects_.Add(type);
 
     RawObject** from = type->from();
@@ skipping 21 matching lines @@
       RawObject** to = type->to();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawTypeRef*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class TypeRefDeserializationCluster : public DeserializationCluster {
  public:
   TypeRefDeserializationCluster() { }
   virtual ~TypeRefDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 14 matching lines @@
       RawObject** from = type->from();
       RawObject** to = type->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class TypeParameterSerializationCluster : public SerializationCluster {
  public:
   TypeParameterSerializationCluster() { }
   virtual ~TypeParameterSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawTypeParameter* type = TypeParameter::RawCast(object);
     objects_.Add(type);
     ASSERT(!type->IsCanonical());
 
@@ skipping 26 matching lines @@
       s->Write<int32_t>(type->ptr()->parameterized_class_id_);
       s->WriteTokenPosition(type->ptr()->token_pos_);
       s->Write<int16_t>(type->ptr()->index_);
       s->Write<int8_t>(type->ptr()->type_state_);
     }
   }
 
  private:
   GrowableArray<RawTypeParameter*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class TypeParameterDeserializationCluster : public DeserializationCluster {
  public:
   TypeParameterDeserializationCluster() { }
   virtual ~TypeParameterDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 20 matching lines @@
       }
       type->ptr()->parameterized_class_id_ = d->Read<int32_t>();
       type->ptr()->token_pos_ = d->ReadTokenPosition();
       type->ptr()->index_ = d->Read<int16_t>();
       type->ptr()->type_state_ = d->Read<int8_t>();
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class BoundedTypeSerializationCluster : public SerializationCluster {
  public:
   BoundedTypeSerializationCluster() { }
   virtual ~BoundedTypeSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawBoundedType* type = BoundedType::RawCast(object);
     objects_.Add(type);
 
     RawObject** from = type->from();
@@ skipping 21 matching lines @@
       RawObject** to = type->to();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawBoundedType*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class BoundedTypeDeserializationCluster : public DeserializationCluster {
  public:
   BoundedTypeDeserializationCluster() { }
   virtual ~BoundedTypeDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 15 matching lines @@
       RawObject** from = type->from();
       RawObject** to = type->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class ClosureSerializationCluster : public SerializationCluster {
  public:
   ClosureSerializationCluster() { }
   virtual ~ClosureSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawClosure* closure = Closure::RawCast(object);
     objects_.Add(closure);
 
     RawObject** from = closure->from();
@@ skipping 22 matching lines @@
       RawObject** to = closure->to();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawClosure*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class ClosureDeserializationCluster : public DeserializationCluster {
  public:
   ClosureDeserializationCluster() { }
   virtual ~ClosureDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 16 matching lines @@
       RawObject** from = closure->from();
       RawObject** to = closure->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class MintSerializationCluster : public SerializationCluster {
  public:
   MintSerializationCluster() { }
   virtual ~MintSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     if (!object->IsHeapObject()) {
       RawSmi* smi = Smi::RawCast(object);
       smis_.Add(smi);
     } else {
@@ skipping 19 matching lines @@
       s->AssignRef(mint);
     }
   }
 
   void WriteFill(Serializer* s) { }
 
  private:
   GrowableArray<RawSmi*> smis_;
   GrowableArray<RawMint*> mints_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class MintDeserializationCluster : public DeserializationCluster {
  public:
   MintDeserializationCluster() { }
   virtual ~MintDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     PageSpace* old_space = d->heap()->old_space();
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
@@ skipping 35 matching lines @@
     }
     const Array& constants_array =
         Array::Handle(zone, Array::MakeArray(new_constants));
     const Class& mint_cls = Class::Handle(zone,
         Isolate::Current()->object_store()->mint_class());
     mint_cls.set_constants(constants_array);
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class BigintSerializationCluster : public SerializationCluster {
  public:
   BigintSerializationCluster() { }
   virtual ~BigintSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawBigint* bigint = Bigint::RawCast(object);
     objects_.Add(bigint);
 
     RawObject** from = bigint->from();
@@ skipping 22 matching lines @@
       RawObject** to = bigint->to();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawBigint*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class BigintDeserializationCluster : public DeserializationCluster {
  public:
   BigintDeserializationCluster() { }
   virtual ~BigintDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 16 matching lines @@
       RawObject** from = bigint->from();
       RawObject** to = bigint->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class DoubleSerializationCluster : public SerializationCluster {
  public:
   DoubleSerializationCluster() { }
   virtual ~DoubleSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawDouble* dbl = Double::RawCast(object);
     objects_.Add(dbl);
   }
 
@@ skipping 12 matching lines @@
     for (intptr_t i = 0; i < count; i++) {
       RawDouble* dbl = objects_[i];
       s->Write<bool>(dbl->IsCanonical());
       s->Write<double>(dbl->ptr()->value_);
     }
   }
 
  private:
   GrowableArray<RawDouble*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class DoubleDeserializationCluster : public DeserializationCluster {
  public:
   DoubleDeserializationCluster() { }
   virtual ~DoubleDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 12 matching lines @@
       bool is_canonical = d->Read<bool>();
       Deserializer::InitializeHeader(dbl, kDoubleCid,
                                      Double::InstanceSize(),
                                      is_vm_object, is_canonical);
       dbl->ptr()->value_ = d->Read<double>();
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class GrowableObjectArraySerializationCluster : public SerializationCluster {
  public:
   GrowableObjectArraySerializationCluster() { }
   virtual ~GrowableObjectArraySerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawGrowableObjectArray* array = GrowableObjectArray::RawCast(object);
     objects_.Add(array);
 
     RawObject** from = array->from();
@@ skipping 22 matching lines @@
       RawObject** to = array->to();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawGrowableObjectArray*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class GrowableObjectArrayDeserializationCluster
     : public DeserializationCluster {
  public:
   GrowableObjectArrayDeserializationCluster() { }
   virtual ~GrowableObjectArrayDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
@@ skipping 19 matching lines @@
       RawObject** from = list->from();
       RawObject** to = list->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class TypedDataSerializationCluster : public SerializationCluster {
  public:
   explicit TypedDataSerializationCluster(intptr_t cid) : cid_(cid) { }
   virtual ~TypedDataSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawTypedData* data = TypedData::RawCast(object);
     objects_.Add(data);
   }
 
@@ skipping 19 matching lines @@
       s->Write<bool>(data->IsCanonical());
       uint8_t* cdata = reinterpret_cast<uint8_t*>(data->ptr()->data());
       s->WriteBytes(cdata, length * element_size);
     }
   }
 
  private:
   const intptr_t cid_;
   GrowableArray<RawTypedData*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class TypedDataDeserializationCluster : public DeserializationCluster {
  public:
   explicit TypedDataDeserializationCluster(intptr_t cid) : cid_(cid) { }
   virtual ~TypedDataDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 23 matching lines @@
       uint8_t* cdata = reinterpret_cast<uint8_t*>(data->ptr()->data());
       d->ReadBytes(cdata, length_in_bytes);
     }
   }
 
  private:
   const intptr_t cid_;
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class ExternalTypedDataSerializationCluster : public SerializationCluster {
  public:
   explicit ExternalTypedDataSerializationCluster(intptr_t cid) : cid_(cid) { }
   virtual ~ExternalTypedDataSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawExternalTypedData* data = ExternalTypedData::RawCast(object);
     objects_.Add(data);
     ASSERT(!data->IsCanonical());
   }
@@ skipping 17 matching lines @@
       s->Write<int32_t>(length);
       uint8_t* cdata = reinterpret_cast<uint8_t*>(data->ptr()->data_);
       s->WriteBytes(cdata, length * element_size);
     }
   }
 
  private:
   const intptr_t cid_;
   GrowableArray<RawExternalTypedData*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class ExternalTypedDataDeserializationCluster : public DeserializationCluster {
  public:
   explicit ExternalTypedDataDeserializationCluster(intptr_t cid) : cid_(cid) { }
   virtual ~ExternalTypedDataDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 21 matching lines @@
       d->Advance(length * element_size);
       // No finalizer / external size 0.
     }
   }
 
  private:
   const intptr_t cid_;
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class StacktraceSerializationCluster : public SerializationCluster {
  public:
   StacktraceSerializationCluster() { }
   virtual ~StacktraceSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawStacktrace* trace = Stacktrace::RawCast(object);
     objects_.Add(trace);
 
     RawObject** from = trace->from();
@@ skipping 21 matching lines @@
       RawObject** to = trace->to();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawStacktrace*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class StacktraceDeserializationCluster : public DeserializationCluster {
  public:
   StacktraceDeserializationCluster() { }
   virtual ~StacktraceDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 15 matching lines @@
       RawObject** from = trace->from();
       RawObject** to = trace->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class RegExpSerializationCluster : public SerializationCluster {
  public:
   RegExpSerializationCluster() { }
   virtual ~RegExpSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawRegExp* regexp = RegExp::RawCast(object);
     objects_.Add(regexp);
 
     RawObject** from = regexp->from();
@@ skipping 24 matching lines @@
       }
 
       s->Write<int32_t>(regexp->ptr()->num_registers_);
       s->Write<int8_t>(regexp->ptr()->type_flags_);
     }
   }
 
  private:
   GrowableArray<RawRegExp*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class RegExpDeserializationCluster : public DeserializationCluster {
  public:
   RegExpDeserializationCluster() { }
   virtual ~RegExpDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 18 matching lines @@
         *p = d->ReadRef();
       }
 
       regexp->ptr()->num_registers_ = d->Read<int32_t>();
       regexp->ptr()->type_flags_ = d->Read<int8_t>();
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class LinkedHashMapSerializationCluster : public SerializationCluster {
  public:
   LinkedHashMapSerializationCluster() { }
   virtual ~LinkedHashMapSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawLinkedHashMap* map = LinkedHashMap::RawCast(object);
     objects_.Add(map);
 
     s->Push(map->ptr()->type_arguments_);
@@ skipping 45 matching lines @@
           s->WriteRef(key);
           s->WriteRef(value);
         }
       }
     }
   }
 
  private:
   GrowableArray<RawLinkedHashMap*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class LinkedHashMapDeserializationCluster : public DeserializationCluster {
  public:
   LinkedHashMapDeserializationCluster() { }
   virtual ~LinkedHashMapDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 41 matching lines @@
       map->ptr()->index_ = TypedData::null();
       map->ptr()->hash_mask_ = Smi::New(0);
       map->ptr()->data_ = data;
       map->ptr()->used_data_ = Smi::New(used_data);
       map->ptr()->deleted_keys_ = Smi::New(0);
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class ArraySerializationCluster : public SerializationCluster {
  public:
   explicit ArraySerializationCluster(intptr_t cid) : cid_(cid) { }
   virtual ~ArraySerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawArray* array = Array::RawCast(object);
     objects_.Add(array);
 
     s->Push(array->ptr()->type_arguments_);
@@ skipping 26 matching lines @@
       for (intptr_t j = 0; j < length; j++) {
         s->WriteRef(array->ptr()->data()[j]);
       }
     }
   }
 
  private:
   intptr_t cid_;
   GrowableArray<RawArray*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class ArrayDeserializationCluster : public DeserializationCluster {
  public:
   explicit ArrayDeserializationCluster(intptr_t cid) : cid_(cid) { }
   virtual ~ArrayDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 23 matching lines @@
         array->ptr()->data()[j] = d->ReadRef();
       }
     }
   }
 
  private:
   const intptr_t cid_;
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class OneByteStringSerializationCluster : public SerializationCluster {
  public:
   OneByteStringSerializationCluster() { }
   virtual ~OneByteStringSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawOneByteString* str = reinterpret_cast<RawOneByteString*>(object);
     objects_.Add(str);
   }
 
@@ skipping 18 matching lines @@
       s->Write<bool>(str->IsCanonical());
       intptr_t hash = Smi::Value(str->ptr()->hash_);
       s->Write<int32_t>(hash);
       s->WriteBytes(str->ptr()->data(), length);
     }
   }
 
  private:
   GrowableArray<RawOneByteString*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class OneByteStringDeserializationCluster : public DeserializationCluster {
  public:
   OneByteStringDeserializationCluster() { }
   virtual ~OneByteStringDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 19 matching lines @@
       str->ptr()->length_ = Smi::New(length);
       str->ptr()->hash_ = Smi::New(d->Read<int32_t>());
       for (intptr_t j = 0; j < length; j++) {
         str->ptr()->data()[j] = d->Read<uint8_t>();
       }
     }
   }
 };
 
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
 class TwoByteStringSerializationCluster : public SerializationCluster {
  public:
   TwoByteStringSerializationCluster() { }
   virtual ~TwoByteStringSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawTwoByteString* str = reinterpret_cast<RawTwoByteString*>(object);
     objects_.Add(str);
   }
 
@@ skipping 18 matching lines @@
       s->Write<bool>(str->IsCanonical());
       intptr_t hash = Smi::Value(str->ptr()->hash_);
       s->Write<int32_t>(hash);
       s->WriteBytes(reinterpret_cast<uint8_t*>(str->ptr()->data()), length * 2);
     }
   }
 
  private:
   GrowableArray<RawTwoByteString*> objects_;
 };
+#endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class TwoByteStringDeserializationCluster : public DeserializationCluster {
  public:
   TwoByteStringDeserializationCluster() { }
   virtual ~TwoByteStringDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
@@ skipping 51 matching lines @@
   }
 }
 
 
 Serializer::~Serializer() {
   delete[] clusters_by_cid_;
 }
 
 
 SerializationCluster* Serializer::NewClusterForClass(intptr_t cid) {
+#if defined(DART_PRECOMPILED_RUNTIME)
+  UNREACHABLE();
+  return NULL;
+#else
   Zone* Z = zone_;
   if ((cid > kNumPredefinedCids) ||
       (cid == kInstanceCid) ||
       RawObject::IsTypedDataViewClassId(cid)) {
     Push(isolate()->class_table()->At(cid));
     return new (Z) InstanceSerializationCluster(cid);
   }
   if (RawObject::IsExternalTypedDataClassId(cid)) {
     return new (Z) ExternalTypedDataSerializationCluster(cid);
   }
@@ skipping 66 matching lines @@
         return new (Z) RODataSerializationCluster(kTwoByteStringCid);
       } else {
         return new (Z) TwoByteStringSerializationCluster();
       }
     }
     default: break;
   }
 
   FATAL1("No cluster defined for cid %" Pd, cid);
   return NULL;
+#endif  // !DART_PRECOMPILED_RUNTIME
 }
 
 
 void Serializer::Trace(RawObject* object) {
   intptr_t cid;
   if (!object->IsHeapObject()) {
     // Smis are merged into the Mint cluster because Smis for the writer might
     // become Mints for the reader and vice versa.
     cid = kMintCid;
   } else {
@@ skipping 796 matching lines @@
 
   deserializer.ReadVMSnapshot();
 
   Dart::set_instructions_snapshot_buffer(instructions_buffer_);
   Dart::set_data_snapshot_buffer(data_buffer_);
 
   return ApiError::null();
 }
 
 }  // namespace dart