Remove dead full snapshot support from the recursive descent serializer.

runtime/vm/snapshot.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 148 matching lines @@
 
 
 intptr_t BaseReader::ReadSmiValue() {
   return Smi::Value(ReadAsSmi());
 }
 
 
 SnapshotReader::SnapshotReader(
     const uint8_t* buffer,
     intptr_t size,
-    const uint8_t* instructions_buffer,
-    const uint8_t* data_buffer,
     Snapshot::Kind kind,
     ZoneGrowableArray<BackRefNode>* backward_refs,
     Thread* thread)
     : BaseReader(buffer, size),
-      instructions_buffer_(instructions_buffer),
-      data_buffer_(data_buffer),
       kind_(kind),
       thread_(thread),
       zone_(thread->zone()),
       heap_(isolate()->heap()),
       old_space_(thread_->isolate()->heap()->old_space()),
       cls_(Class::Handle(zone_)),
       obj_(Object::Handle(zone_)),
       pobj_(PassiveObject::Handle(zone_)),
       array_(Array::Handle(zone_)),
       field_(Field::Handle(zone_)),
       str_(String::Handle(zone_)),
       library_(Library::Handle(zone_)),
       type_(AbstractType::Handle(zone_)),
       type_arguments_(TypeArguments::Handle(zone_)),
       tokens_(GrowableObjectArray::Handle(zone_)),
       stream_(TokenStream::Handle(zone_)),
       data_(ExternalTypedData::Handle(zone_)),
       typed_data_(TypedData::Handle(zone_)),
-      code_(Code::Handle(zone_)),
       function_(Function::Handle(zone_)),
-      megamorphic_cache_(MegamorphicCache::Handle(zone_)),
       error_(UnhandledException::Handle(zone_)),
       max_vm_isolate_object_id_(
           (Snapshot::IsFull(kind)) ?
               Object::vm_isolate_snapshot_object_table().Length() : 0),
-      backward_references_(backward_refs),
-      instructions_reader_(NULL) {
-  if (instructions_buffer != NULL) {
-    instructions_reader_ =
-        new InstructionsReader(instructions_buffer, data_buffer);
-  }
+      backward_references_(backward_refs) {
 }
 
 
 RawObject* SnapshotReader::ReadObject() {
   // Setup for long jump in case there is an exception while reading.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     PassiveObject& obj =
         PassiveObject::Handle(zone(), ReadObjectImpl(kAsInlinedObject));
     for (intptr_t i = 0; i < backward_references_->length(); i++) {
       if (!(*backward_references_)[i].is_deserialized()) {
         ReadObjectImpl(kAsInlinedObject);
         (*backward_references_)[i].set_state(kIsDeserialized);
       }
     }
-    if (!Snapshot::IsFull(kind())) {
-      ProcessDeferredCanonicalizations();
-    }
+    ProcessDeferredCanonicalizations();
     return obj.raw();
   } else {
     // An error occurred while reading, return the error object.
     const Error& err = Error::Handle(thread()->sticky_error());
     thread()->clear_sticky_error();
     return err.raw();
   }
 }
 
 
@@ skipping 237 matching lines @@
   if (result == NULL) {
     result = &(Instance::ZoneHandle(zone(), Instance::null()));
     AddBackRef(object_id, result, state);
     cls_ ^= ReadObjectImpl(kAsInlinedObject);
     ASSERT(!cls_.IsNull());
     // Closure instances are handled by Closure::ReadFrom().
     ASSERT(!cls_.IsClosureClass());
     instance_size = cls_.instance_size();
     ASSERT(instance_size > 0);
     // Allocate the instance and read in all the fields for the object.
-    if (Snapshot::IsFull(kind_)) {
-      *result ^= AllocateUninitialized(cls_.id(), instance_size);
-    } else {
-      *result ^= Object::Allocate(cls_.id(), instance_size, HEAP_SPACE(kind_));
-    }
+    *result ^= Object::Allocate(cls_.id(), instance_size, HEAP_SPACE(kind_));
   } else {
     cls_ ^= ReadObjectImpl(kAsInlinedObject);
     ASSERT(!cls_.IsNull());
     instance_size = cls_.instance_size();
   }
   if (!as_reference) {
     // Read all the individual fields for inlined objects.
     intptr_t next_field_offset = cls_.next_field_offset();
 
     intptr_t type_argument_field_offset = cls_.type_arguments_field_offset();
@@ skipping 17 matching lines @@
         field_ ^= array_.At(offset >> kWordSizeLog2);
         ASSERT(!field_.IsNull());
         ASSERT(field_.Offset() == offset);
         obj_ = pobj_.raw();
         field_.RecordStore(obj_);
       }
       // TODO(fschneider): Verify the guarded cid and length for other kinds of
       // snapshot (kFull, kScript) with asserts.
       offset += kWordSize;
     }
-    if (Snapshot::IsFull(kind_)) {
-      // We create an uninitialized object in the case of full snapshots, so
-      // we need to initialize any remaining padding area with the Null object.
-      while (offset < instance_size) {
-        result->SetFieldAtOffset(offset, Object::null_object());
-        offset += kWordSize;
-      }
-    }
     if (RawObject::IsCanonical(tags)) {
-      if (Snapshot::IsFull(kind_)) {
-        result->SetCanonical();
-      } else {
-        *result = result->CheckAndCanonicalize(thread(), NULL);
-        ASSERT(!result->IsNull());
-      }
+      *result = result->CheckAndCanonicalize(thread(), NULL);
+      ASSERT(!result->IsNull());
     }
   }
   return result->raw();
 }
 
 
 void SnapshotReader::AddBackRef(intptr_t id,
                                 Object* obj,
                                 DeserializeState state,
                                 bool defer_canonicalization) {
@@ skipping 124 matching lines @@
     // allocate the error message in old space.
     const String& msg = String::Handle(String::New(message_buffer, Heap::kOld));
     return ApiError::New(msg, Heap::kOld);
   }
   free(const_cast<char*>(expected_features));
   Advance(expected_len + 1);
   return ApiError::null();
 }
 
 
-#define ALLOC_NEW_OBJECT_WITH_LEN(type, length)                                \
-  ASSERT(Snapshot::IsFull(kind_));                                            \
-  ASSERT_NO_SAFEPOINT_SCOPE();                                                 \
-  Raw##type* obj = reinterpret_cast<Raw##type*>(                               \
-      AllocateUninitialized(k##type##Cid, type::InstanceSize(length)));        \
-  obj->StoreSmi(&(obj->ptr()->length_), Smi::New(length));                     \
-  return obj;                                                                  \
-
-
-RawArray* SnapshotReader::NewArray(intptr_t len) {
-  ALLOC_NEW_OBJECT_WITH_LEN(Array, len);
-}
-
-
-RawImmutableArray* SnapshotReader::NewImmutableArray(intptr_t len) {
-  ALLOC_NEW_OBJECT_WITH_LEN(ImmutableArray, len);
-}
-
-
-RawOneByteString* SnapshotReader::NewOneByteString(intptr_t len) {
-  ALLOC_NEW_OBJECT_WITH_LEN(OneByteString, len);
-}
-
-
-RawTwoByteString* SnapshotReader::NewTwoByteString(intptr_t len) {
-  ALLOC_NEW_OBJECT_WITH_LEN(TwoByteString, len);
-}
-
-
-RawTypeArguments* SnapshotReader::NewTypeArguments(intptr_t len) {
-  ALLOC_NEW_OBJECT_WITH_LEN(TypeArguments, len);
-}
-
-
-RawObjectPool* SnapshotReader::NewObjectPool(intptr_t len) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  RawObjectPool* obj = reinterpret_cast<RawObjectPool*>(
-      AllocateUninitialized(kObjectPoolCid, ObjectPool::InstanceSize(len)));
-  obj->ptr()->length_ = len;
-  return obj;
-}
-
-
-RawLocalVarDescriptors* SnapshotReader::NewLocalVarDescriptors(
-    intptr_t num_entries) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  RawLocalVarDescriptors* obj = reinterpret_cast<RawLocalVarDescriptors*>(
-      AllocateUninitialized(kLocalVarDescriptorsCid,
-                            LocalVarDescriptors::InstanceSize(num_entries)));
-  obj->ptr()->num_entries_ = num_entries;
-  return obj;
-}
-
-
-RawExceptionHandlers* SnapshotReader::NewExceptionHandlers(
-    intptr_t num_entries) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  RawExceptionHandlers* obj = reinterpret_cast<RawExceptionHandlers*>(
-      AllocateUninitialized(kExceptionHandlersCid,
-                            ExceptionHandlers::InstanceSize(num_entries)));
-  obj->ptr()->num_entries_ = num_entries;
-  return obj;
-}
-
-
-RawPcDescriptors* SnapshotReader::NewPcDescriptors(intptr_t len) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  RawPcDescriptors* obj = reinterpret_cast<RawPcDescriptors*>(
-      AllocateUninitialized(kPcDescriptorsCid,
-                            PcDescriptors::InstanceSize(len)));
-  obj->ptr()->length_ = len;
-  return obj;
-}
-
-
-RawCodeSourceMap* SnapshotReader::NewCodeSourceMap(intptr_t len) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  RawCodeSourceMap* obj = reinterpret_cast<RawCodeSourceMap*>(
-      AllocateUninitialized(kCodeSourceMapCid,
-                            CodeSourceMap::InstanceSize(len)));
-  obj->ptr()->length_ = len;
-  return obj;
-}
-
-
-RawStackmap* SnapshotReader::NewStackmap(intptr_t len) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  RawStackmap* obj = reinterpret_cast<RawStackmap*>(
-      AllocateUninitialized(kStackmapCid, Stackmap::InstanceSize(len)));
-  obj->ptr()->length_ = len;
-  return obj;
-}
-
-
-RawContextScope* SnapshotReader::NewContextScope(intptr_t num_variables) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  RawContextScope* obj = reinterpret_cast<RawContextScope*>(
-      AllocateUninitialized(kContextScopeCid,
-                            ContextScope::InstanceSize(num_variables)));
-  obj->ptr()->num_variables_ = num_variables;
-  return obj;
-}
-
-
-RawCode* SnapshotReader::NewCode(intptr_t pointer_offsets_length) {
-  ASSERT(pointer_offsets_length == 0);
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  RawCode* obj = reinterpret_cast<RawCode*>(
-      AllocateUninitialized(kCodeCid, Code::InstanceSize(0)));
-  return obj;
-}
-
-
-RawTokenStream* SnapshotReader::NewTokenStream(intptr_t len) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  stream_ = reinterpret_cast<RawTokenStream*>(
-      AllocateUninitialized(kTokenStreamCid, TokenStream::InstanceSize()));
-  uint8_t* array = const_cast<uint8_t*>(CurrentBufferAddress());
-  ASSERT(array != NULL);
-  Advance(len);
-  data_ = reinterpret_cast<RawExternalTypedData*>(
-      AllocateUninitialized(kExternalTypedDataUint8ArrayCid,
-                            ExternalTypedData::InstanceSize()));
-  data_.SetData(array);
-  data_.SetLength(len);
-  stream_.SetStream(data_);
-  return stream_.raw();
-}
-
-
-RawContext* SnapshotReader::NewContext(intptr_t num_variables) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  RawContext* obj = reinterpret_cast<RawContext*>(
-      AllocateUninitialized(kContextCid, Context::InstanceSize(num_variables)));
-  obj->ptr()->num_variables_ = num_variables;
-  return obj;
-}
-
-
-RawClass* SnapshotReader::NewClass(intptr_t class_id) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  if (class_id < kNumPredefinedCids) {
-    ASSERT((class_id >= kInstanceCid) &&
-           (class_id <= kNullCid));
-    return isolate()->class_table()->At(class_id);
-  }
-  RawClass* obj = reinterpret_cast<RawClass*>(
-      AllocateUninitialized(kClassCid, Class::InstanceSize()));
-  Instance fake;
-  obj->ptr()->handle_vtable_ = fake.vtable();
-  cls_ = obj;
-  cls_.set_id(class_id);
-  isolate()->RegisterClassAt(class_id, cls_);
-  return cls_.raw();
-}
-
-
-RawInstance* SnapshotReader::NewInstance() {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  RawInstance* obj = reinterpret_cast<RawInstance*>(
-      AllocateUninitialized(kInstanceCid, Instance::InstanceSize()));
-  return obj;
-}
-
-
-RawMint* SnapshotReader::NewMint(int64_t value) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  RawMint* obj = reinterpret_cast<RawMint*>(
-      AllocateUninitialized(kMintCid, Mint::InstanceSize()));
-  obj->ptr()->value_ = value;
-  return obj;
-}
-
-
-RawDouble* SnapshotReader::NewDouble(double value) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  RawDouble* obj = reinterpret_cast<RawDouble*>(
-      AllocateUninitialized(kDoubleCid, Double::InstanceSize()));
-  obj->ptr()->value_ = value;
-  return obj;
-}
-
-
-RawTypedData* SnapshotReader::NewTypedData(intptr_t class_id, intptr_t len) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  const intptr_t lengthInBytes = len * TypedData::ElementSizeInBytes(class_id);
-  RawTypedData* obj = reinterpret_cast<RawTypedData*>(
-      AllocateUninitialized(class_id, TypedData::InstanceSize(lengthInBytes)));
-  obj->StoreSmi(&(obj->ptr()->length_), Smi::New(len));
-  return obj;
-}
-
-
-#define ALLOC_NEW_OBJECT(type)                                                 \
-  ASSERT(Snapshot::IsFull(kind_));                                            \
-  ASSERT_NO_SAFEPOINT_SCOPE();                                                 \
-  return reinterpret_cast<Raw##type*>(                                         \
-      AllocateUninitialized(k##type##Cid, type::InstanceSize()));              \
-
-
-RawBigint* SnapshotReader::NewBigint() {
-  ALLOC_NEW_OBJECT(Bigint);
-}
-
-
-RawUnresolvedClass* SnapshotReader::NewUnresolvedClass() {
-  ALLOC_NEW_OBJECT(UnresolvedClass);
-}
-
-
-RawType* SnapshotReader::NewType() {
-  ALLOC_NEW_OBJECT(Type);
-}
-
-
-RawTypeRef* SnapshotReader::NewTypeRef() {
-  ALLOC_NEW_OBJECT(TypeRef);
-}
-
-
-RawTypeParameter* SnapshotReader::NewTypeParameter() {
-  ALLOC_NEW_OBJECT(TypeParameter);
-}
-
-
-RawBoundedType* SnapshotReader::NewBoundedType() {
-  ALLOC_NEW_OBJECT(BoundedType);
-}
-
-
-RawMixinAppType* SnapshotReader::NewMixinAppType() {
-  ALLOC_NEW_OBJECT(MixinAppType);
-}
-
-
-RawPatchClass* SnapshotReader::NewPatchClass() {
-  ALLOC_NEW_OBJECT(PatchClass);
-}
-
-
-RawClosure* SnapshotReader::NewClosure() {
-  ALLOC_NEW_OBJECT(Closure);
-}
-
-
-RawClosureData* SnapshotReader::NewClosureData() {
-  ALLOC_NEW_OBJECT(ClosureData);
-}
-
-
-RawRedirectionData* SnapshotReader::NewRedirectionData() {
-  ALLOC_NEW_OBJECT(RedirectionData);
-}
-
-
-RawFunction* SnapshotReader::NewFunction() {
-  ALLOC_NEW_OBJECT(Function);
-}
-
-
-RawICData* SnapshotReader::NewICData() {
-  ALLOC_NEW_OBJECT(ICData);
-}
-
-
-RawLinkedHashMap* SnapshotReader::NewLinkedHashMap() {
-  ALLOC_NEW_OBJECT(LinkedHashMap);
-}
-
-
-RawMegamorphicCache* SnapshotReader::NewMegamorphicCache() {
-  ALLOC_NEW_OBJECT(MegamorphicCache);
-}
-
-
-RawSubtypeTestCache* SnapshotReader::NewSubtypeTestCache() {
-  ALLOC_NEW_OBJECT(SubtypeTestCache);
-}
-
-
-RawField* SnapshotReader::NewField() {
-  ALLOC_NEW_OBJECT(Field);
-}
-
-
-RawLibrary* SnapshotReader::NewLibrary() {
-  ALLOC_NEW_OBJECT(Library);
-}
-
-
-RawLibraryPrefix* SnapshotReader::NewLibraryPrefix() {
-  ALLOC_NEW_OBJECT(LibraryPrefix);
-}
-
-
-RawNamespace* SnapshotReader::NewNamespace() {
-  ALLOC_NEW_OBJECT(Namespace);
-}
-
-
-RawScript* SnapshotReader::NewScript() {
-  ALLOC_NEW_OBJECT(Script);
-}
-
-
-RawLiteralToken* SnapshotReader::NewLiteralToken() {
-  ALLOC_NEW_OBJECT(LiteralToken);
-}
-
-
-RawGrowableObjectArray* SnapshotReader::NewGrowableObjectArray() {
-  ALLOC_NEW_OBJECT(GrowableObjectArray);
-}
-
-
-RawWeakProperty* SnapshotReader::NewWeakProperty() {
-  ALLOC_NEW_OBJECT(WeakProperty);
-}
-
-
-RawRegExp* SnapshotReader::NewRegExp() {
-  ALLOC_NEW_OBJECT(RegExp);
-}
-
-
-RawFloat32x4* SnapshotReader::NewFloat32x4(float v0, float v1, float v2,
-                                           float v3) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  RawFloat32x4* obj = reinterpret_cast<RawFloat32x4*>(
-      AllocateUninitialized(kFloat32x4Cid, Float32x4::InstanceSize()));
-  obj->ptr()->value_[0] = v0;
-  obj->ptr()->value_[1] = v1;
-  obj->ptr()->value_[2] = v2;
-  obj->ptr()->value_[3] = v3;
-  return obj;
-}
-
-
-RawInt32x4* SnapshotReader::NewInt32x4(uint32_t v0, uint32_t v1, uint32_t v2,
-                                       uint32_t v3) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  RawInt32x4* obj = reinterpret_cast<RawInt32x4*>(
-      AllocateUninitialized(kInt32x4Cid, Int32x4::InstanceSize()));
-  obj->ptr()->value_[0] = v0;
-  obj->ptr()->value_[1] = v1;
-  obj->ptr()->value_[2] = v2;
-  obj->ptr()->value_[3] = v3;
-  return obj;
-}
-
-
-RawFloat64x2* SnapshotReader::NewFloat64x2(double v0, double v1) {
-  ASSERT(Snapshot::IsFull(kind_));
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  RawFloat64x2* obj = reinterpret_cast<RawFloat64x2*>(
-      AllocateUninitialized(kFloat64x2Cid, Float64x2::InstanceSize()));
-  obj->ptr()->value_[0] = v0;
-  obj->ptr()->value_[1] = v1;
-  return obj;
-}
-
-
-RawApiError* SnapshotReader::NewApiError() {
-  ALLOC_NEW_OBJECT(ApiError);
-}
-
-
-RawLanguageError* SnapshotReader::NewLanguageError() {
-  ALLOC_NEW_OBJECT(LanguageError);
-}
-
-
-RawUnhandledException* SnapshotReader::NewUnhandledException() {
-  ALLOC_NEW_OBJECT(UnhandledException);
-}
-
-
 RawObject* SnapshotReader::NewInteger(int64_t value) {
   ASSERT((value & kSmiTagMask) == kSmiTag);
   value = value >> kSmiTagShift;
   if (Smi::IsValid(value)) {
     return Smi::New(static_cast<intptr_t>(value));
   }
-  if (Snapshot::IsFull(kind_)) {
-    return NewMint(value);
-  }
   return Mint::NewCanonical(value);
 }
 
 
-RawStacktrace* SnapshotReader::NewStacktrace() {
-  ALLOC_NEW_OBJECT(Stacktrace);
-}
-
-
 int32_t InstructionsWriter::GetOffsetFor(RawInstructions* instructions,
                                          RawCode* code) {
 #if defined(PRODUCT)
   // Instructions are only dedup in product mode because it obfuscates profiler
   // results.
   for (intptr_t i = 0; i < instructions_.length(); i++) {
     if (instructions_[i].raw_insns_ == instructions) {
       return instructions_[i].offset_;
     }
   }
@@ skipping 309 matching lines @@
     ASSERT(IsSingletonClassId(class_id));
     return class_id;
   }
   ASSERT(SerializedHeaderTag::decode(class_header) == kObjectId);
   intptr_t class_id = SerializedHeaderData::decode(class_header);
   ASSERT(IsObjectStoreClassId(class_id) || IsSingletonClassId(class_id));
   return class_id;
 }
 
 
-RawObject* SnapshotReader::AllocateUninitialized(intptr_t class_id,
-                                                 intptr_t size) {
-  ASSERT_NO_SAFEPOINT_SCOPE();
-  ASSERT(Utils::IsAligned(size, kObjectAlignment));
-
-  uword address =
-      old_space()->TryAllocateDataBumpLocked(size, PageSpace::kForceGrowth);
-  if (address == 0) {
-    // Use the preallocated out of memory exception to avoid calling
-    // into dart code or allocating any code.
-    // We do a longjmp at this point to unwind out of the entire
-    // read part and return the error object back.
-    const UnhandledException& error = UnhandledException::Handle(
-        object_store()->preallocated_unhandled_exception());
-    thread()->long_jump_base()->Jump(1, error);
-  }
-
-  RawObject* raw_obj = reinterpret_cast<RawObject*>(address + kHeapObjectTag);
-  uword tags = 0;
-  ASSERT(class_id != kIllegalCid);
-  tags = RawObject::ClassIdTag::update(class_id, tags);
-  tags = RawObject::SizeTag::update(size, tags);
-  tags = RawObject::VMHeapObjectTag::update(is_vm_isolate(), tags);
-  raw_obj->ptr()->tags_ = tags;
-  return raw_obj;
-}
-
-
 #define READ_VM_SINGLETON_OBJ(id, obj)                                         \
   if (object_id == id) {                                                       \
     return obj;                                                                \
   }                                                                            \
 
 RawObject* SnapshotReader::ReadVMIsolateObject(intptr_t header_value) {
   intptr_t object_id = GetVMIsolateObjectId(header_value);
 
   // First check if it is one of the singleton objects.
   READ_VM_SINGLETON_OBJ(kNullObject, Object::null());
@@ skipping 50 matching lines @@
 }
 
 
 RawObject* SnapshotReader::ReadIndexedObject(intptr_t object_id,
                                              intptr_t patch_object_id,
                                              intptr_t patch_offset) {
   intptr_t class_id = ClassIdFromObjectId(object_id);
   if (IsObjectStoreClassId(class_id)) {
     return isolate()->class_table()->At(class_id);  // get singleton class.
   }
-  if (!Snapshot::IsFull(kind_)) {
-    if (IsObjectStoreTypeId(object_id)) {
-      return GetType(object_store(), object_id);  // return type obj.
-    }
+  if (IsObjectStoreTypeId(object_id)) {
+    return GetType(object_store(), object_id);  // return type obj.
   }
   ASSERT(object_id >= kMaxPredefinedObjectIds);
   intptr_t index = (object_id - kMaxPredefinedObjectIds);
   if (index < max_vm_isolate_object_id_) {
     return VmIsolateSnapshotObject(index);
   }
   AddPatchRecord(object_id, patch_object_id, patch_offset);
   return GetBackRef(object_id)->raw();
 }
 
 
 void SnapshotReader::AddPatchRecord(intptr_t object_id,
                                     intptr_t patch_object_id,
                                     intptr_t patch_offset) {
-  if (patch_object_id != kInvalidPatchIndex && !Snapshot::IsFull(kind())) {
+  if (patch_object_id != kInvalidPatchIndex) {
     ASSERT(object_id >= kMaxPredefinedObjectIds);
     intptr_t index = (object_id - kMaxPredefinedObjectIds);
     ASSERT(index >= max_vm_isolate_object_id_);
     index -= max_vm_isolate_object_id_;
     ASSERT(index < backward_references_->length());
     BackRefNode& ref = (*backward_references_)[index];
     ref.AddPatchRecord(patch_object_id, patch_offset);
   }
 }
 
@@ skipping 64 matching lines @@
     result.SetAt(i, *PassiveObjectHandle());
   }
 }
 
 
 ScriptSnapshotReader::ScriptSnapshotReader(const uint8_t* buffer,
                                            intptr_t size,
                                            Thread* thread)
     : SnapshotReader(buffer,
                      size,
-                     NULL, /* instructions_buffer */
-                     NULL, /* data_buffer */
                      Snapshot::kScript,
                      new ZoneGrowableArray<BackRefNode>(kNumInitialReferences),
                      thread) {
 }
 
 
 ScriptSnapshotReader::~ScriptSnapshotReader() {
   ResetBackwardReferenceTable();
 }
 
 
 MessageSnapshotReader::MessageSnapshotReader(const uint8_t* buffer,
                                              intptr_t size,
                                              Thread* thread)
     : SnapshotReader(buffer,
                      size,
-                     NULL, /* instructions_buffer */
-                     NULL, /* data_buffer */
                      Snapshot::kMessage,
                      new ZoneGrowableArray<BackRefNode>(kNumInitialReferences),
                      thread) {
 }
 
 
 MessageSnapshotReader::~MessageSnapshotReader() {
   ResetBackwardReferenceTable();
 }
 
 
 SnapshotWriter::SnapshotWriter(Thread* thread,
                                Snapshot::Kind kind,
                                uint8_t** buffer,
                                ReAlloc alloc,
                                intptr_t initial_size,
                                ForwardList* forward_list,
-                               InstructionsWriter* instructions_writer,
-                               bool can_send_any_object,
-                               bool writing_vm_isolate)
+                               bool can_send_any_object)
     : BaseWriter(buffer, alloc, initial_size),
       thread_(thread),
       kind_(kind),
       object_store_(isolate()->object_store()),
       class_table_(isolate()->class_table()),
       forward_list_(forward_list),
-      instructions_writer_(instructions_writer),
       exception_type_(Exceptions::kNone),
       exception_msg_(NULL),
-      unmarked_objects_(false),
-      can_send_any_object_(can_send_any_object),
-      writing_vm_isolate_(writing_vm_isolate) {
+      can_send_any_object_(can_send_any_object) {
   ASSERT(forward_list_ != NULL);
 }
 
 
 void SnapshotWriter::WriteObject(RawObject* rawobj) {
   WriteObjectImpl(rawobj, kAsInlinedObject);
   WriteForwardedObjects();
 }
 
 
@@ skipping 71 matching lines @@
   }
 
   // Check if it is a singleton ICData array object.
   for (intptr_t i = 0; i < ICData::kCachedICDataArrayCount; i++) {
     if (rawobj == ICData::cached_icdata_arrays_[i]) {
       WriteVMIsolateObject(kCachedICDataArray0 + i);
       return true;
     }
   }
 
-  if (writing_vm_isolate_) {
-    // When we are writing the VM isolate snapshot, write out the object
-    // itself instead of a VM object id.
-    return false;
-  }
-
-  if (Snapshot::IsFull(kind())) {
-    // Check it is a predefined symbol in the VM isolate.
-    id = Symbols::LookupPredefinedSymbol(rawobj);
-    if (id != kInvalidIndex) {
-      WriteVMIsolateObject(id);
-      return true;
-    }
-
-    // Check if it is an object from the vm isolate snapshot object table.
-    id = FindVmSnapshotObject(rawobj);
-    if (id != kInvalidIndex) {
-      WriteIndexedObject(id);
-      return true;
-    }
+  // In the case of script snapshots or for messages we do not use
+  // the index into the vm isolate snapshot object table, instead we
+  // explicitly write the object out.
+  intptr_t object_id = forward_list_->FindObject(rawobj);
+  if (object_id != -1) {
+    WriteIndexedObject(object_id);
+    return true;
   } else {
-    // In the case of script snapshots or for messages we do not use
-    // the index into the vm isolate snapshot object table, instead we
-    // explicitly write the object out.
-    intptr_t object_id = forward_list_->FindObject(rawobj);
-    if (object_id != -1) {
-      WriteIndexedObject(object_id);
-      return true;
-    } else {
-      switch (id) {
-        VM_OBJECT_CLASS_LIST(VM_OBJECT_WRITE)
-        case kTypedDataUint32ArrayCid: {
-          object_id = forward_list_->AddObject(zone(), rawobj, kIsSerialized);
-          RawTypedData* raw_obj = reinterpret_cast<RawTypedData*>(rawobj);
-          raw_obj->WriteTo(this, object_id, kind(), false);
-          return true;
-        }
-        default:
-          OS::Print("class id = %" Pd "\n", id);
-          break;
+    switch (id) {
+      VM_OBJECT_CLASS_LIST(VM_OBJECT_WRITE)
+      case kTypedDataUint32ArrayCid: {
+        object_id = forward_list_->AddObject(zone(), rawobj, kIsSerialized);
+        RawTypedData* raw_obj = reinterpret_cast<RawTypedData*>(rawobj);
+        raw_obj->WriteTo(this, object_id, kind(), false);
+        return true;
       }
+      default:
+        OS::Print("class id = %" Pd "\n", id);
+        break;
     }
   }
 
   const Object& obj = Object::Handle(rawobj);
   FATAL1("Unexpected reference to object in VM isolate: %s\n", obj.ToCString());
   return false;
 }
 
 #undef VM_OBJECT_WRITE
 
@@ skipping 103 matching lines @@
   }
 
   // Now check if it is an object from the VM isolate. These objects are shared
   // by all isolates.
   if (rawobj->IsVMHeapObject() && HandleVMIsolateObject(rawobj)) {
     return true;
   }
 
   // Check if it is a code object in that case just write a Null object
   // as we do not want code objects in the snapshot.
-  if (cid == kCodeCid && !Snapshot::IncludesCode(kind_)) {
+  if (cid == kCodeCid) {
     WriteVMIsolateObject(kNullObject);
     return true;
   }
 
   // Check if classes are not being serialized and it is preinitialized type
   // or a predefined internal VM class in the object store.
-  if (!Snapshot::IsFull(kind_)) {
-    // Check if it is an internal VM class which is in the object store.
-    if (cid == kClassCid) {
-      RawClass* raw_class = reinterpret_cast<RawClass*>(rawobj);
-      intptr_t class_id = raw_class->ptr()->id_;
-      if (IsObjectStoreClassId(class_id)) {
-        intptr_t object_id = ObjectIdFromClassId(class_id);
-        WriteIndexedObject(object_id);
-        return true;
-      }
-    }
-
-    // Now check it is a preinitialized type object.
-    RawType* raw_type = reinterpret_cast<RawType*>(rawobj);
-    intptr_t index = GetTypeIndex(object_store(), raw_type);
-    if (index != kInvalidIndex) {
-      WriteIndexedObject(index);
+  // Check if it is an internal VM class which is in the object store.
+  if (cid == kClassCid) {
+    RawClass* raw_class = reinterpret_cast<RawClass*>(rawobj);
+    intptr_t class_id = raw_class->ptr()->id_;
+    if (IsObjectStoreClassId(class_id)) {
+      intptr_t object_id = ObjectIdFromClassId(class_id);
+      WriteIndexedObject(object_id);
       return true;
     }
   }
 
+  // Now check it is a preinitialized type object.
+  RawType* raw_type = reinterpret_cast<RawType*>(rawobj);
+  intptr_t index = GetTypeIndex(object_store(), raw_type);
+  if (index != kInvalidIndex) {
+    WriteIndexedObject(index);
+    return true;
+  }
+
   return false;
 }
 
 
 void SnapshotWriter::WriteObjectImpl(RawObject* raw, bool as_reference) {
   // First check if object can be written as a simple predefined type.
   if (CheckAndWritePredefinedObject(raw)) {
     return;
   }
 
@@ skipping 380 matching lines @@
 
 
 ScriptSnapshotWriter::ScriptSnapshotWriter(uint8_t** buffer,
                                            ReAlloc alloc)
     : SnapshotWriter(Thread::Current(),
                      Snapshot::kScript,
                      buffer,
                      alloc,
                      kInitialSize,
                      &forward_list_,
-                     NULL, /* instructions_writer */
-                     true, /* can_send_any_object */
-                     false /* writing_vm_isolate */),
+                     true /* can_send_any_object */),
       forward_list_(thread(), kMaxPredefinedObjectIds) {
   ASSERT(buffer != NULL);
   ASSERT(alloc != NULL);
 }
 
 
 void ScriptSnapshotWriter::WriteScriptSnapshot(const Library& lib) {
   ASSERT(kind() == Snapshot::kScript);
   ASSERT(isolate() != NULL);
   ASSERT(ClassFinalizer::AllClassesFinalized());
@@ skipping 33 matching lines @@
 
 MessageWriter::MessageWriter(uint8_t** buffer,
                              ReAlloc alloc,
                              bool can_send_any_object)
     : SnapshotWriter(Thread::Current(),
                      Snapshot::kMessage,
                      buffer,
                      alloc,
                      kInitialSize,
                      &forward_list_,
-                     NULL, /* instructions_writer */
-                     can_send_any_object,
-                     false /* writing_vm_isolate */),
+                     can_send_any_object),
       forward_list_(thread(), kMaxPredefinedObjectIds) {
   ASSERT(buffer != NULL);
   ASSERT(alloc != NULL);
 }
 
 
 void MessageWriter::WriteMessage(const Object& obj) {
   ASSERT(kind() == Snapshot::kMessage);
   ASSERT(isolate() != NULL);
 
   // Setup for long jump in case there is an exception while writing
   // the message.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart