Split Snapshot::kFull into kCore, kAppWithJIT, and kAppNoJIT. Remove snapshot_code flag.

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 164 matching lines @@
     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),
-      snapshot_code_(instructions_buffer != NULL),
       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_(
-          (kind == Snapshot::kFull) ?
+          (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);
   }
 }
 
 
 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 (kind() != Snapshot::kFull) {
+    if (!Snapshot::IsFull(kind())) {
       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();
   }
 }
 
 
 RawClass* SnapshotReader::ReadClassId(intptr_t object_id) {
-  ASSERT(kind_ != Snapshot::kFull);
+  ASSERT(!Snapshot::IsFull(kind_));
   // Read the class header information and lookup the class.
   intptr_t class_header = Read<int32_t>();
   ASSERT((class_header & kSmiTagMask) != kSmiTag);
   ASSERT(!IsVMIsolateObject(class_header) ||
          !IsSingletonClassId(GetVMIsolateObjectId(class_header)));
   ASSERT((SerializedHeaderTag::decode(class_header) != kObjectId) ||
          !IsObjectStoreClassId(SerializedHeaderData::decode(class_header)));
   Class& cls = Class::ZoneHandle(zone(), Class::null());
   AddBackRef(object_id, &cls, kIsDeserialized);
   // Read the library/class information and lookup the class.
@@ skipping 44 matching lines @@
   }
   if (func.IsNull()) {
     SetReadException("Expected a function name, but found an invalid name.");
   }
   return func.raw();
 }
 
 
 RawObject* SnapshotReader::ReadStaticImplicitClosure(intptr_t object_id,
                                                      intptr_t class_header) {
-  ASSERT(kind_ != Snapshot::kFull);
+  ASSERT(!Snapshot::IsFull(kind_));
 
   // First create a function object and associate it with the specified
   // 'object_id'.
   Function& func = Function::Handle(zone(), Function::null());
   Instance& obj = Instance::ZoneHandle(zone(), Instance::null());
   AddBackRef(object_id, &obj, kIsDeserialized);
 
   // Read the library/class/function information and lookup the function.
   str_ ^= ReadObjectImpl(kAsInlinedObject);
   library_ = Library::LookupLibrary(str_);
@@ skipping 160 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 (kind_ == Snapshot::kFull) {
+    if (Snapshot::IsFull(kind_)) {
       *result ^= AllocateUninitialized(cls_.id(), instance_size);
     } else {
       *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) {
@@ skipping 21 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 (kind_ == Snapshot::kFull) {
+    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 (kind_ == Snapshot::kFull) {
+      if (Snapshot::IsFull(kind_)) {
         result->SetCanonical();
       } else {
         *result = result->CheckAndCanonicalize(thread(), NULL);
         ASSERT(!result->IsNull());
       }
     }
   }
   return result->raw();
 }
 
@@ skipping 32 matching lines @@
   ~HeapLocker() {
     page_space_->ReleaseDataLock();
   }
 
  private:
   PageSpace* page_space_;
 };
 
 
 RawApiError* SnapshotReader::ReadFullSnapshot() {
-  ASSERT(kind_ == Snapshot::kFull);
+  ASSERT(Snapshot::IsFull(kind_));
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   ObjectStore* object_store = isolate->object_store();
   ASSERT(object_store != NULL);
 
   // First read the version string, and check that it matches.
   RawApiError* error = VerifyVersion();
   if (error != ApiError::null()) {
     return error;
   }
 
   // The version string matches. Read the rest of the snapshot.
 
   // TODO(asiva): Add a check here to ensure we have the right heap
   // size for the full snapshot being read.
   {
     NoSafepointScope no_safepoint;
     HeapLocker hl(thread, old_space());
 
     // Read in all the objects stored in the object store.
-    RawObject** toobj = snapshot_code() ? object_store->to()
-                                        : object_store->to_snapshot();
-    intptr_t num_flds = (toobj - object_store->from());
+    intptr_t num_flds =
+        (object_store->to_snapshot(kind_) - object_store->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
       *(object_store->from() + i) = 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_code()) {
+    if (Snapshot::IncludesCode(kind_)) {
       ICData& ic = ICData::Handle(thread->zone());
       Object& funcOrCode = Object::Handle(thread->zone());
       Code& code = Code::Handle(thread->zone());
       Smi& entry_point = Smi::Handle(thread->zone());
       for (intptr_t i = 0; i < backward_references_->length(); i++) {
         if ((*backward_references_)[i].reference()->IsICData()) {
           ic ^= (*backward_references_)[i].reference()->raw();
           for (intptr_t j = 0; j < ic.NumberOfChecks(); j++) {
             funcOrCode = ic.GetTargetOrCodeAt(j);
             if (funcOrCode.IsCode()) {
@@ skipping 76 matching lines @@
 
   const char* version = reinterpret_cast<const char*>(CurrentBufferAddress());
   ASSERT(version != NULL);
   if (strncmp(version, expected_version, version_len)) {
     const intptr_t kMessageBufferSize = 256;
     char message_buffer[kMessageBufferSize];
     char* actual_version = OS::StrNDup(version, version_len);
     OS::SNPrint(message_buffer,
                 kMessageBufferSize,
                 "Wrong %s snapshot version, expected '%s' found '%s'",
-                (kind_ == Snapshot::kFull) ? "full" : "script",
+                (Snapshot::IsFull(kind_)) ? "full" : "script",
                 Version::SnapshotString(),
                 actual_version);
     free(actual_version);
     // This can also fail while bringing up the VM isolate, so make sure to
     // allocate the error message in old space.
     const String& msg = String::Handle(String::New(message_buffer, Heap::kOld));
     return ApiError::New(msg, Heap::kOld);
   }
   Advance(version_len);
   return ApiError::null();
 }
 
 
 #define ALLOC_NEW_OBJECT_WITH_LEN(type, length)                                \
-  ASSERT(kind_ == Snapshot::kFull);                                            \
+  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);
 }
@@ skipping 13 matching lines @@
   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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);                                            \
+  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);
 }
 
 
@@ skipping 112 matching lines @@
 }
 
 
 RawRegExp* SnapshotReader::NewRegExp() {
   ALLOC_NEW_OBJECT(RegExp);
 }
 
 
 RawFloat32x4* SnapshotReader::NewFloat32x4(float v0, float v1, float v2,
                                            float v3) {
-  ASSERT(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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(kind_ == Snapshot::kFull);
+  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() {
@@ skipping 10 matching lines @@
   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 (kind_ == Snapshot::kFull) {
+  if (Snapshot::IsFull(kind_)) {
     return NewMint(value);
   }
   return Mint::NewCanonical(value);
 }
 
 
 RawStacktrace* SnapshotReader::NewStacktrace() {
   ALLOC_NEW_OBJECT(Stacktrace);
 }
 
@@ skipping 371 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 (kind_ != Snapshot::kFull) {
+  if (!Snapshot::IsFull(kind_)) {
     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 && kind() != Snapshot::kFull) {
+  if (patch_object_id != kInvalidPatchIndex && !Snapshot::IsFull(kind())) {
     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 60 matching lines @@
   for (intptr_t i = 0; i < len; i++) {
     *PassiveObjectHandle() = ReadObjectImpl(as_reference,
                                             object_id,
                                             (i + offset));
     result.SetAt(i, *PassiveObjectHandle());
   }
 }
 
 
 VmIsolateSnapshotReader::VmIsolateSnapshotReader(
+    Snapshot::Kind kind,
     const uint8_t* buffer,
     intptr_t size,
     const uint8_t* instructions_buffer,
     const uint8_t* data_buffer,
     Thread* thread)
       : SnapshotReader(buffer,
                        size,
                        instructions_buffer,
                        data_buffer,
-                       Snapshot::kFull,
+                       kind,
                        new ZoneGrowableArray<BackRefNode>(
                            kNumVmIsolateSnapshotReferences),
                        thread) {
+  ASSERT(Snapshot::IsFull(kind));
 }
 
 
 VmIsolateSnapshotReader::~VmIsolateSnapshotReader() {
   intptr_t len = GetBackwardReferenceTable()->length();
   Object::InitVmIsolateSnapshotObjectTable(len);
   ZoneGrowableArray<BackRefNode>* backrefs = GetBackwardReferenceTable();
   for (intptr_t i = 0; i < len; i++) {
     Object::vm_isolate_snapshot_object_table().SetAt(
         i, *(backrefs->At(i).reference()));
   }
   ResetBackwardReferenceTable();
   Dart::set_instructions_snapshot_buffer(instructions_buffer_);
   Dart::set_data_snapshot_buffer(data_buffer_);
 }
 
 
 RawApiError* VmIsolateSnapshotReader::ReadVmIsolateSnapshot() {
-  ASSERT(kind() == Snapshot::kFull);
+  ASSERT(Snapshot::IsFull(kind()));
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   ASSERT(isolate == Dart::vm_isolate());
   ObjectStore* object_store = isolate->object_store();
   ASSERT(object_store != NULL);
 
   // First read the version string, and check that it matches.
   RawApiError* error = VerifyVersion();
   if (error != ApiError::null()) {
     return error;
   }
 
   // The version string matches. Read the rest of the snapshot.
 
   {
     NoSafepointScope no_safepoint;
     HeapLocker hl(thread, old_space());
 
     // Read in the symbol table.
     object_store->symbol_table_ = reinterpret_cast<RawArray*>(ReadObject());
 
     Symbols::InitOnceFromSnapshot(isolate);
 
     // Read in all the script objects and the accompanying token streams
     // for bootstrap libraries so that they are in the VM isolate's read
     // only memory.
     *(ArrayHandle()) ^= ReadObject();
 
-    if (snapshot_code()) {
+    if (Snapshot::IncludesCode(kind())) {
       StubCode::ReadFrom(this);
     }
 
     // Validate the class table.
 #if defined(DEBUG)
     isolate->ValidateClassTable();
 #endif
 
     return ApiError::null();
   }
 }
 
 
-IsolateSnapshotReader::IsolateSnapshotReader(const uint8_t* buffer,
+IsolateSnapshotReader::IsolateSnapshotReader(Snapshot::Kind kind,
+                                             const uint8_t* buffer,
                                              intptr_t size,
                                              const uint8_t* instructions_buffer,
                                              const uint8_t* data_buffer,
                                              Thread* thread)
     : SnapshotReader(buffer,
                      size,
                      instructions_buffer,
                      data_buffer,
-                     Snapshot::kFull,
+                     kind,
                      new ZoneGrowableArray<BackRefNode>(
                          kNumInitialReferencesInFullSnapshot),
                      thread) {
   isolate()->set_compilation_allowed(instructions_buffer_ == NULL);
+  ASSERT(Snapshot::IsFull(kind));
 }
 
 
 IsolateSnapshotReader::~IsolateSnapshotReader() {
   ResetBackwardReferenceTable();
 }
 
 
 ScriptSnapshotReader::ScriptSnapshotReader(const uint8_t* buffer,
                                            intptr_t size,
@@ skipping 24 matching lines @@
                      new ZoneGrowableArray<BackRefNode>(kNumInitialReferences),
                      thread) {
 }
 
 
 MessageSnapshotReader::~MessageSnapshotReader() {
   ResetBackwardReferenceTable();
 }
 
 
-SnapshotWriter::SnapshotWriter(Snapshot::Kind kind,
-                               Thread* thread,
+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 snapshot_code,
                                bool vm_isolate_is_symbolic)
     : BaseWriter(buffer, alloc, initial_size),
+      thread_(thread),
       kind_(kind),
-      thread_(thread),
       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),
-      snapshot_code_(snapshot_code),
       vm_isolate_is_symbolic_(vm_isolate_is_symbolic) {
   ASSERT(forward_list_ != NULL);
 }
 
 
 void SnapshotWriter::WriteObject(RawObject* rawobj) {
   WriteObjectImpl(rawobj, kAsInlinedObject);
   WriteForwardedObjects();
 }
 
@@ skipping 72 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 (kind() == Snapshot::kFull) {
+  if (Snapshot::IsFull(kind())) {
     // Check it is a predefined symbol in the VM isolate.
     id = Symbols::LookupVMSymbol(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) {
@@ skipping 64 matching lines @@
 
   intptr_t count() const { return count_; }
 
  private:
   Object& objHandle_;
   intptr_t count_;
   const Array* scripts_;
 };
 
 
-FullSnapshotWriter::FullSnapshotWriter(uint8_t** vm_isolate_snapshot_buffer,
+FullSnapshotWriter::FullSnapshotWriter(Snapshot::Kind kind,
+                                       uint8_t** vm_isolate_snapshot_buffer,
                                        uint8_t** isolate_snapshot_buffer,
                                        ReAlloc alloc,
                                        InstructionsWriter* instructions_writer,
-                                       bool snapshot_code,
                                        bool vm_isolate_is_symbolic)
     : thread_(Thread::Current()),
+      kind_(kind),
       vm_isolate_snapshot_buffer_(vm_isolate_snapshot_buffer),
       isolate_snapshot_buffer_(isolate_snapshot_buffer),
       alloc_(alloc),
       vm_isolate_snapshot_size_(0),
       isolate_snapshot_size_(0),
       forward_list_(NULL),
       instructions_writer_(instructions_writer),
       scripts_(Array::Handle(zone())),
       symbol_table_(Array::Handle(zone())),
-      snapshot_code_(snapshot_code),
       vm_isolate_is_symbolic_(vm_isolate_is_symbolic) {
   ASSERT(isolate_snapshot_buffer_ != NULL);
   ASSERT(alloc_ != NULL);
   ASSERT(isolate() != NULL);
   ASSERT(ClassFinalizer::AllClassesFinalized());
   ASSERT(isolate() != NULL);
   ASSERT(heap() != NULL);
   ObjectStore* object_store = isolate()->object_store();
   ASSERT(object_store != NULL);
   // Ensure the class table is valid.
@@ skipping 31 matching lines @@
   if (!symbol_table_.IsNull()) {
     isolate()->object_store()->set_symbol_table(symbol_table_);
     symbol_table_ = Array::null();
   }
   scripts_ = Array::null();
 }
 
 
 void FullSnapshotWriter::WriteVmIsolateSnapshot() {
   ASSERT(vm_isolate_snapshot_buffer_ != NULL);
-  SnapshotWriter writer(Snapshot::kFull,
-                        thread(),
+  SnapshotWriter writer(thread(),
+                        kind_,
                         vm_isolate_snapshot_buffer_,
                         alloc_,
                         kInitialSize,
                         forward_list_,
                         instructions_writer_,
                         true, /* can_send_any_object */
-                        snapshot_code_,
                         vm_isolate_is_symbolic_);
   // Write full snapshot for the VM isolate.
   // Setup for long jump in case there is an exception while writing
   // the snapshot.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Reserve space in the output buffer for a snapshot header.
     writer.ReserveHeader();
 
     // Write out the version string.
     writer.WriteVersion();
 
     /*
      * Now Write out the following
      * - the symbol table
      * - all the scripts and token streams for these scripts
      *
      **/
     // Write out the symbol table.
     writer.WriteObject(symbol_table_.raw());
 
     // Write out all the script objects and the accompanying token streams
     // for the bootstrap libraries so that they are in the VM isolate
     // read only memory.
     writer.WriteObject(scripts_.raw());
 
-    if (snapshot_code_) {
+    if (Snapshot::IncludesCode(kind_)) {
       ASSERT(!vm_isolate_is_symbolic_);
       StubCode::WriteTo(&writer);
     }
 
 
     writer.FillHeader(writer.kind());
 
     vm_isolate_snapshot_size_ = writer.BytesWritten();
   } else {
     writer.ThrowException(writer.exception_type(), writer.exception_msg());
   }
 }
 
 
 void FullSnapshotWriter::WriteIsolateFullSnapshot() {
-  SnapshotWriter writer(Snapshot::kFull,
-                        thread(),
+  SnapshotWriter writer(thread(),
+                        kind_,
                         isolate_snapshot_buffer_,
                         alloc_,
                         kInitialSize,
                         forward_list_,
                         instructions_writer_,
                         true, /* can_send_any_object */
-                        snapshot_code_,
                         true /* vm_isolate_is_symbolic */);
   ObjectStore* object_store = isolate()->object_store();
   ASSERT(object_store != NULL);
 
   // Write full snapshot for a regular isolate.
   // Setup for long jump in case there is an exception while writing
   // the snapshot.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Reserve space in the output buffer for a snapshot header.
     writer.ReserveHeader();
 
     // Write out the version string.
     writer.WriteVersion();
 
     // Write out the full snapshot.
 
     // Write out all the objects in the object store of the isolate which
     // is the root set for all dart allocated objects at this point.
     SnapshotWriterVisitor visitor(&writer, false);
     visitor.VisitPointers(object_store->from(),
-                          snapshot_code_ ? object_store->to()
-                                         : object_store->to_snapshot());
+                          object_store->to_snapshot(kind_));
 
     // Write out all forwarded objects.
     writer.WriteForwardedObjects();
 
     writer.FillHeader(writer.kind());
 
     isolate_snapshot_size_ = writer.BytesWritten();
   } else {
     writer.ThrowException(writer.exception_type(), writer.exception_msg());
   }
 }
 
 
 void FullSnapshotWriter::WriteFullSnapshot() {
   if (vm_isolate_snapshot_buffer() != NULL) {
     WriteVmIsolateSnapshot();
   }
   WriteIsolateFullSnapshot();
-  if (snapshot_code_) {
+  if (Snapshot::IncludesCode(kind_)) {
     instructions_writer_->Write();
 
     OS::Print("VMIsolate(CodeSize): %" Pd "\n", VmIsolateSnapshotSize());
     OS::Print("Isolate(CodeSize): %" Pd "\n", IsolateSnapshotSize());
     OS::Print("Instructions(CodeSize): %" Pd "\n",
               instructions_writer_->binary_size());
     intptr_t total = VmIsolateSnapshotSize() +
                      IsolateSnapshotSize() +
                      instructions_writer_->binary_size();
     OS::Print("Total(CodeSize): %" Pd "\n", total);
   }
 }
 
 
 PrecompiledSnapshotWriter::PrecompiledSnapshotWriter(
     uint8_t** vm_isolate_snapshot_buffer,
     uint8_t** isolate_snapshot_buffer,
     ReAlloc alloc,
     InstructionsWriter* instructions_writer)
-  : FullSnapshotWriter(vm_isolate_snapshot_buffer,
+  : FullSnapshotWriter(Snapshot::kAppNoJIT,
+                       vm_isolate_snapshot_buffer,
                        isolate_snapshot_buffer,
                        alloc,
                        instructions_writer,
-                       true, /* snapshot_code */
                        false /* vm_isolate_is_symbolic */) {
 }
 
 
 PrecompiledSnapshotWriter::~PrecompiledSnapshotWriter() {}
 
 
 ForwardList::ForwardList(Thread* thread, intptr_t first_object_id)
     : thread_(thread),
       first_object_id_(first_object_id),
@@ skipping 65 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_code()) {
+  if (cid == kCodeCid && !Snapshot::IncludesCode(kind_)) {
     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 (kind_ != Snapshot::kFull) {
+  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;
       }
     }
@@ skipping 134 matching lines @@
 
       // Mark object as serialized.
       NodeForObjectId(id)->set_state(kIsSerialized);
     }
   }
   first_unprocessed_object_id_ = next_object_id();
 }
 
 
 void SnapshotWriter::WriteClassId(RawClass* cls) {
-  ASSERT(kind_ != Snapshot::kFull);
+  ASSERT(!Snapshot::IsFull(kind_));
   int class_id = cls->ptr()->id_;
   ASSERT(!IsSingletonClassId(class_id) && !IsObjectStoreClassId(class_id));
 
   // Write out the library url and class name.
   RawLibrary* library = cls->ptr()->library_;
   ASSERT(library != Library::null());
   WriteObjectImpl(library->ptr()->url_, kAsInlinedObject);
   WriteObjectImpl(cls->ptr()->name_, kAsInlinedObject);
 }
 
@@ skipping 239 matching lines @@
 
 intptr_t SnapshotWriter::FirstObjectId() {
   intptr_t max_vm_isolate_object_id =
       Object::vm_isolate_snapshot_object_table().Length();
   return kMaxPredefinedObjectIds + max_vm_isolate_object_id;
 }
 
 
 ScriptSnapshotWriter::ScriptSnapshotWriter(uint8_t** buffer,
                                            ReAlloc alloc)
-    : SnapshotWriter(Snapshot::kScript,
-                     Thread::Current(),
+    : SnapshotWriter(Thread::Current(),
+                     Snapshot::kScript,
                      buffer,
                      alloc,
                      kInitialSize,
                      &forward_list_,
                      NULL, /* instructions_writer */
                      true, /* can_send_any_object */
-                     false, /* snapshot_code */
                      true /* vm_isolate_is_symbolic */),
       forward_list_(thread(), kMaxPredefinedObjectIds) {
   ASSERT(buffer != NULL);
   ASSERT(alloc != NULL);
 }
 
 
 void ScriptSnapshotWriter::WriteScriptSnapshot(const Library& lib) {
   ASSERT(kind() == Snapshot::kScript);
   ASSERT(isolate() != NULL);
@@ skipping 28 matching lines @@
   for (RawObject** current = first; current <= last; current++) {
     RawObject* raw_obj = *current;
     writer_->WriteObjectImpl(raw_obj, as_references_);
   }
 }
 
 
 MessageWriter::MessageWriter(uint8_t** buffer,
                              ReAlloc alloc,
                              bool can_send_any_object)
-    : SnapshotWriter(Snapshot::kMessage,
-                     Thread::Current(),
+    : SnapshotWriter(Thread::Current(),
+                     Snapshot::kMessage,
                      buffer,
                      alloc,
                      kInitialSize,
                      &forward_list_,
                      NULL, /* instructions_writer */
                      can_send_any_object,
-                     false, /* snapshot_code */
                      true /* vm_isolate_is_symbolic */),
       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