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

runtime/vm/raw_object_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/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 #define NEW_OBJECT(type)                                                       \
-  ((kind == Snapshot::kFull) ? reader->New##type() : type::New())
+  ((Snapshot::IsFull(kind)) ? reader->New##type() : type::New())
 
 #define NEW_OBJECT_WITH_LEN(type, len)                                         \
-  ((kind == Snapshot::kFull) ? reader->New##type(len) : type::New(len))
+  ((Snapshot::IsFull(kind)) ? reader->New##type(len) : type::New(len))
 
 #define NEW_OBJECT_WITH_LEN_SPACE(type, len, kind)                             \
-  ((kind == Snapshot::kFull) ?                                                 \
+  ((Snapshot::IsFull(kind)) ?                                                  \
   reader->New##type(len) : type::New(len, HEAP_SPACE(kind)))
 
 #define OFFSET_OF_FROM(obj)                                                    \
   obj.raw()->from() - reinterpret_cast<RawObject**>(obj.raw()->ptr())
 
 // TODO(18854): Need to assert No GC can happen here, even though
 // allocations may happen.
 #define READ_OBJECT_FIELDS(object, from, to, as_reference)                     \
   intptr_t num_flds = (to) - (from);                                           \
   intptr_t from_offset = OFFSET_OF_FROM(object);                               \
   for (intptr_t i = 0; i <= num_flds; i++) {                                   \
     (*reader->PassiveObjectHandle()) =                                         \
         reader->ReadObjectImpl(as_reference, object_id, (i + from_offset));    \
     object.StorePointer(((from) + i),                                          \
                         reader->PassiveObjectHandle()->raw());                 \
   }
 
 RawClass* Class::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind,
                           bool as_reference) {
   ASSERT(reader != NULL);
 
   Class& cls = Class::ZoneHandle(reader->zone(), Class::null());
   bool is_in_fullsnapshot = reader->Read<bool>();
-  if ((kind == Snapshot::kFull) ||
+  if (Snapshot::IsFull(kind) ||
       (kind == Snapshot::kScript && !is_in_fullsnapshot)) {
     // Read in the base information.
     classid_t class_id = reader->ReadClassIDValue();
 
     // Allocate class object of specified kind.
-    if (kind == Snapshot::kFull) {
+    if (Snapshot::IsFull(kind)) {
       cls = reader->NewClass(class_id);
     } else {
       if (class_id < kNumPredefinedCids) {
         ASSERT((class_id >= kInstanceCid) && (class_id <= kMirrorReferenceCid));
         cls = reader->isolate()->class_table()->At(class_id);
       } else {
         cls = New<Instance>(kIllegalCid);
       }
     }
     reader->AddBackRef(object_id, &cls, kIsDeserialized);
 
     // Set all non object fields.
     if (!RawObject::IsInternalVMdefinedClassId(class_id)) {
       // Instance size of a VM defined class is already set up.
       cls.set_instance_size_in_words(reader->Read<int32_t>());
       cls.set_next_field_offset_in_words(reader->Read<int32_t>());
     }
     cls.set_type_arguments_field_offset_in_words(reader->Read<int32_t>());
     cls.set_num_type_arguments(reader->Read<int16_t>());
     cls.set_num_own_type_arguments(reader->Read<int16_t>());
     cls.set_num_native_fields(reader->Read<uint16_t>());
     cls.set_token_pos(TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
     cls.set_state_bits(reader->Read<uint16_t>());
 
     // Set all the object fields.
     READ_OBJECT_FIELDS(cls, cls.raw()->from(), cls.raw()->to(), kAsReference);
-    ASSERT(!cls.IsInFullSnapshot() || (kind == Snapshot::kFull));
+    ASSERT(!cls.IsInFullSnapshot() || (Snapshot::IsFull(kind)));
   } else {
     cls ^= reader->ReadClassId(object_id);
     ASSERT((kind == Snapshot::kMessage) || cls.IsInFullSnapshot());
   }
   return cls.raw();
 }
 
 
 void RawClass::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind,
                        bool as_reference) {
   ASSERT(writer != NULL);
   bool is_in_fullsnapshot = Class::IsInFullSnapshot(this);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kClassCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the boolean is_in_fullsnapshot first as this will
   // help the reader decide how the rest of the information needs
   // to be interpreted.
   writer->Write<bool>(is_in_fullsnapshot);
 
-  if ((kind == Snapshot::kFull) ||
+  if (Snapshot::IsFull(kind) ||
       (kind == Snapshot::kScript && !is_in_fullsnapshot)) {
     // Write out all the non object pointer fields.
     // NOTE: cpp_vtable_ is not written.
     classid_t class_id = ptr()->id_;
     ASSERT(class_id != kIllegalCid);
     writer->Write<classid_t>(class_id);
     if (!RawObject::IsInternalVMdefinedClassId(class_id)) {
       // We don't write the instance size of VM defined classes as they
       // are already setup during initialization as part of pre populating
       // the class table.
@@ skipping 97 matching lines @@
                         bool as_reference) {
   ASSERT(reader != NULL);
 
   // Determine if the type class of this type is in the full snapshot.
   bool typeclass_is_in_fullsnapshot = reader->Read<bool>();
 
   // Allocate type object.
   Type& type = Type::ZoneHandle(reader->zone(), NEW_OBJECT(Type));
   bool is_canonical = RawObject::IsCanonical(tags);
   bool defer_canonicalization = is_canonical &&
-      (kind != Snapshot::kFull && typeclass_is_in_fullsnapshot);
+      (!Snapshot::IsFull(kind) && typeclass_is_in_fullsnapshot);
   reader->AddBackRef(object_id, &type, kIsDeserialized, defer_canonicalization);
 
   // Set all non object fields.
   type.set_token_pos(TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
   type.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(type, type.raw()->from(), type.raw()->to(), kAsReference);
 
   // Set the canonical bit.
@@ skipping 200 matching lines @@
                                           Snapshot::Kind kind,
                                           bool as_reference) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
   intptr_t len = reader->ReadSmiValue();
 
   TypeArguments& type_arguments = TypeArguments::ZoneHandle(
       reader->zone(), NEW_OBJECT_WITH_LEN_SPACE(TypeArguments, len, kind));
   bool is_canonical = RawObject::IsCanonical(tags);
-  bool defer_canonicalization = is_canonical && (kind != Snapshot::kFull);
+  bool defer_canonicalization = is_canonical && (!Snapshot::IsFull(kind));
   reader->AddBackRef(object_id,
                      &type_arguments,
                      kIsDeserialized,
                      defer_canonicalization);
 
   // Set the instantiations field, which is only read from a full snapshot.
-  if (kind == Snapshot::kFull) {
+  if (Snapshot::IsFull(kind)) {
     *(reader->ArrayHandle()) ^= reader->ReadObjectImpl(kAsInlinedObject);
     type_arguments.set_instantiations(*(reader->ArrayHandle()));
   } else {
     type_arguments.set_instantiations(Object::zero_array());
   }
 
   // Now set all the type fields.
   intptr_t offset = type_arguments.TypeAddr(0) -
       reinterpret_cast<RawAbstractType**>(type_arguments.raw()->ptr());
   for (intptr_t i = 0; i < len; i++) {
@@ skipping 21 matching lines @@
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kTypeArgumentsCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the length field.
   writer->Write<RawObject*>(ptr()->length_);
 
   // Write out the instantiations field, but only in a full snapshot.
-  if (kind == Snapshot::kFull) {
+  if (Snapshot::IsFull(kind)) {
     writer->WriteObjectImpl(ptr()->instantiations_, kAsInlinedObject);
   }
 
   // Write out the individual types.
   intptr_t len = Smi::Value(ptr()->length_);
   for (intptr_t i = 0; i < len; i++) {
     writer->WriteObjectImpl(ptr()->types()[i], kAsReference);
   }
 }
 
 
 RawPatchClass* PatchClass::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind,
                                     bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate function object.
   PatchClass& cls = PatchClass::ZoneHandle(reader->zone(),
                                             NEW_OBJECT(PatchClass));
   reader->AddBackRef(object_id, &cls, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(cls, cls.raw()->from(), cls.raw()->to(), kAsReference);
 
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
   return cls.raw();
 }
 
 
 void RawPatchClass::WriteTo(SnapshotWriter* writer,
                             intptr_t object_id,
                             Snapshot::Kind kind,
                             bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kPatchClassCid);
   writer->WriteTags(writer->GetObjectTags(this));
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer, kAsReference);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawClosure* Closure::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind,
                               bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IsFull(kind));
 
   // Allocate closure object.
   Closure& closure = Closure::ZoneHandle(
       reader->zone(), NEW_OBJECT(Closure));
   reader->AddBackRef(object_id, &closure, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(closure,
                      closure.raw()->from(), closure.raw()->to(),
                      kAsReference);
@@ skipping 34 matching lines @@
   visitor.VisitPointers(from(), to());
 }
 
 
 RawClosureData* ClosureData::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind,
                                       bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Allocate closure data object.
   ClosureData& data = ClosureData::ZoneHandle(
       reader->zone(), NEW_OBJECT(ClosureData));
   reader->AddBackRef(object_id, &data, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(data,
                      data.raw()->from(), data.raw()->to(),
                      kAsInlinedObject);
 
   return data.raw();
 }
 
 
 void RawClosureData::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind,
                              bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kClosureDataCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Context scope.
   if (ptr()->context_scope_ == Object::empty_context_scope().raw()) {
@@ skipping 17 matching lines @@
   writer->WriteObjectImpl(ptr()->closure_, kAsInlinedObject);
 }
 
 
 RawRedirectionData* RedirectionData::ReadFrom(SnapshotReader* reader,
                                               intptr_t object_id,
                                               intptr_t tags,
                                               Snapshot::Kind kind,
                                               bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Allocate redirection data object.
   RedirectionData& data = RedirectionData::ZoneHandle(
       reader->zone(), NEW_OBJECT(RedirectionData));
   reader->AddBackRef(object_id, &data, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(data,
                      data.raw()->from(), data.raw()->to(),
                      kAsReference);
 
   return data.raw();
 }
 
 
 void RawRedirectionData::WriteTo(SnapshotWriter* writer,
                                  intptr_t object_id,
                                  Snapshot::Kind kind,
                                  bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kRedirectionDataCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer, kAsReference);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawFunction* Function::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind,
                                 bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   bool is_in_fullsnapshot = reader->Read<bool>();
-  if ((kind == Snapshot::kFull) || !is_in_fullsnapshot) {
+  if ((Snapshot::IsFull(kind)) || !is_in_fullsnapshot) {
     // Allocate function object.
     Function& func = Function::ZoneHandle(
         reader->zone(), NEW_OBJECT(Function));
     reader->AddBackRef(object_id, &func, kIsDeserialized);
 
     // Set all the non object fields. Read the token positions now but
     // don't set them until after setting the kind.
     const int32_t token_pos = reader->Read<int32_t>();
     const int32_t end_token_pos = reader->Read<uint32_t>();
     func.set_num_fixed_parameters(reader->Read<int16_t>());
     func.set_num_optional_parameters(reader->Read<int16_t>());
     func.set_kind_tag(reader->Read<uint32_t>());
     func.set_token_pos(TokenPosition::SnapshotDecode(token_pos));
     func.set_end_token_pos(TokenPosition::SnapshotDecode(end_token_pos));
-    if (reader->snapshot_code()) {
+    if (Snapshot::IncludesCode(kind)) {
       func.set_usage_counter(0);
       func.set_deoptimization_counter(0);
       func.set_optimized_instruction_count(0);
       func.set_optimized_call_site_count(0);
     } else {
       func.set_usage_counter(reader->Read<int32_t>());
       func.set_deoptimization_counter(reader->Read<int8_t>());
       func.set_optimized_instruction_count(reader->Read<uint16_t>());
       func.set_optimized_call_site_count(reader->Read<uint16_t>());
     }
     func.set_was_compiled(false);
 
     // Set all the object fields.
     READ_OBJECT_FIELDS(func,
                        func.raw()->from(), func.raw()->to_snapshot(),
                        kAsReference);
     // Initialize all fields that are not part of the snapshot.
-    if (reader->snapshot_code()) {
+    if (Snapshot::IncludesCode(kind)) {
       func.ClearICDataArray();
       func.ClearCode();
       // Read the code object and fixup entry point.
       (*reader->CodeHandle()) ^= reader->ReadObjectImpl(kAsInlinedObject);
       func.SetInstructions(*reader->CodeHandle());
     } else {
       bool is_optimized = func.usage_counter() != 0;
       if (is_optimized) {
         // Read the ic data array as the function is an optimized one.
         (*reader->ArrayHandle()) ^= reader->ReadObjectImpl(kAsReference);
         func.set_ic_data_array(*reader->ArrayHandle());
       } else {
         func.ClearICDataArray();
       }
       func.ClearCode();
     }
     return func.raw();
   } else {
     return reader->ReadFunctionId(object_id);
   }
 }
 
 
 void RawFunction::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind,
                           bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
   bool is_in_fullsnapshot = false;
   bool owner_is_class = false;
   if ((kind == Snapshot::kScript) && !Function::IsSignatureFunction(this)) {
     intptr_t tags = writer->GetObjectTags(ptr()->owner_);
     intptr_t cid = ClassIdTag::decode(tags);
     owner_is_class = (cid == kClassCid);
     is_in_fullsnapshot =  owner_is_class ?
         Class::IsInFullSnapshot(reinterpret_cast<RawClass*>(ptr()->owner_)) :
         PatchClass::IsInFullSnapshot(
             reinterpret_cast<RawPatchClass*>(ptr()->owner_));
   }
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kFunctionCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the boolean is_in_fullsnapshot first as this will
   // help the reader decide how the rest of the information needs
   // to be interpreted.
   writer->Write<bool>(is_in_fullsnapshot);
 
-  if (kind == Snapshot::kFull || !is_in_fullsnapshot) {
+  if (Snapshot::IsFull(kind) || !is_in_fullsnapshot) {
     bool is_optimized = Code::IsOptimized(ptr()->code_);
 
     // Write out all the non object fields.
     writer->Write<int32_t>(ptr()->token_pos_.SnapshotEncode());
     writer->Write<int32_t>(ptr()->end_token_pos_.SnapshotEncode());
     writer->Write<int16_t>(ptr()->num_fixed_parameters_);
     writer->Write<int16_t>(ptr()->num_optional_parameters_);
     writer->Write<uint32_t>(ptr()->kind_tag_);
-    if (writer->snapshot_code()) {
+    if (Snapshot::IncludesCode(kind)) {
       // Omit fields used to support de/reoptimization.
     } else {
       if (is_optimized) {
         writer->Write<int32_t>(FLAG_optimization_counter_threshold);
       } else {
         writer->Write<int32_t>(0);
       }
       writer->Write<int8_t>(ptr()->deoptimization_counter_);
       writer->Write<uint16_t>(ptr()->optimized_instruction_count_);
       writer->Write<uint16_t>(ptr()->optimized_call_site_count_);
     }
 
     // Write out all the object pointer fields.
     SnapshotWriterVisitor visitor(writer, kAsReference);
     visitor.VisitPointers(from(), to_snapshot());
-    if (writer->snapshot_code()) {
+    if (Snapshot::IncludesCode(kind)) {
       ASSERT(ptr()->ic_data_array_ == Array::null());
       ASSERT((ptr()->code_ == ptr()->unoptimized_code_) ||
              (ptr()->unoptimized_code_ == Code::null()));
       // Write out the code object as we are generating a precompiled snapshot.
       writer->WriteObjectImpl(ptr()->code_, kAsInlinedObject);
     } else if (is_optimized) {
       // Write out the ic data array as the function is optimized or
       // we are generating a precompiled snapshot.
       writer->WriteObjectImpl(ptr()->ic_data_array_, kAsReference);
     }
   } else {
     writer->WriteFunctionId(this, owner_is_class);
   }
 }
 
 
 RawField* Field::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind,
                           bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Allocate field object.
   Field& field = Field::ZoneHandle(reader->zone(), NEW_OBJECT(Field));
   reader->AddBackRef(object_id, &field, kIsDeserialized);
 
   // Set all non object fields.
-  if (reader->snapshot_code()) {
+  if (Snapshot::IncludesCode(kind)) {
     field.set_token_pos(TokenPosition::kNoSource);
     ASSERT(!FLAG_use_field_guards);
   } else {
     field.set_token_pos(
         TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
     field.set_guarded_cid(reader->Read<int32_t>());
     field.set_is_nullable(reader->Read<int32_t>());
   }
   field.set_kind_bits(reader->Read<uint8_t>());
 
   // Set all the object fields.
-  RawObject** toobj = reader->snapshot_code()
-      ? field.raw()->to_precompiled_snapshot()
-      : field.raw()->to();
   READ_OBJECT_FIELDS(field,
-                     field.raw()->from(), toobj,
+                     field.raw()->from(),
+                     field.raw()->to_snapshot(kind),
                      kAsReference);
 
   if (!FLAG_use_field_guards) {
     field.set_guarded_cid(kDynamicCid);
     field.set_is_nullable(true);
     field.set_guarded_list_length(Field::kNoFixedLength);
     field.set_guarded_list_length_in_object_offset(Field::kUnknownLengthOffset);
   } else {
     field.InitializeGuardedListLengthInObjectOffset();
   }
 
   return field.raw();
 }
 
 
 void RawField::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind,
                        bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kFieldCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the non object fields.
-  if (!writer->snapshot_code()) {
+  if (!Snapshot::IncludesCode(kind)) {
     writer->Write<int32_t>(ptr()->token_pos_.SnapshotEncode());
     writer->Write<int32_t>(ptr()->guarded_cid_);
     writer->Write<int32_t>(ptr()->is_nullable_);
   }
   writer->Write<uint8_t>(ptr()->kind_bits_);
 
   // Write out the name.
   writer->WriteObjectImpl(ptr()->name_, kAsReference);
   // Write out the owner.
   writer->WriteObjectImpl(ptr()->owner_, kAsReference);
   // Write out the type.
   writer->WriteObjectImpl(ptr()->type_, kAsReference);
   // Write out the initial static value or field offset.
   if (Field::StaticBit::decode(ptr()->kind_bits_)) {
-    if (writer->snapshot_code()) {
+    if (Snapshot::IncludesCode(kind)) {
       // For precompiled static fields, the value was already reset and
       // initializer_ now contains a Function.
       writer->WriteObjectImpl(ptr()->value_.static_value_, kAsReference);
     } else {
       // Otherwise, for static fields we write out the initial static value.
       writer->WriteObjectImpl(ptr()->initializer_.saved_value_, kAsReference);
     }
   } else {
     writer->WriteObjectImpl(ptr()->value_.offset_, kAsReference);
   }
   // Write out the initializer function or saved initial value.
-  if (writer->snapshot_code()) {
+  if (Snapshot::IncludesCode(kind)) {
     writer->WriteObjectImpl(ptr()->initializer_.precompiled_, kAsReference);
   } else {
     writer->WriteObjectImpl(ptr()->initializer_.saved_value_, kAsReference);
   }
-  if (!writer->snapshot_code()) {
+  if (!Snapshot::IncludesCode(kind)) {
     // Write out the dependent code.
     writer->WriteObjectImpl(ptr()->dependent_code_, kAsReference);
     // Write out the guarded list length.
     writer->WriteObjectImpl(ptr()->guarded_list_length_, kAsReference);
   }
 }
 
 
 RawLiteralToken* LiteralToken::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
@@ skipping 43 matching lines @@
   visitor.VisitPointers(from(), to());
 }
 
 
 RawTokenStream* TokenStream::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind,
                                       bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Read the length so that we can determine number of tokens to read.
   intptr_t len = reader->ReadSmiValue();
 
   // Create the token stream object.
   TokenStream& token_stream = TokenStream::ZoneHandle(
       reader->zone(), NEW_OBJECT_WITH_LEN(TokenStream, len));
   reader->AddBackRef(object_id, &token_stream, kIsDeserialized);
 
   // Read the stream of tokens into the TokenStream object for script
@@ skipping 13 matching lines @@
 
   return token_stream.raw();
 }
 
 
 void RawTokenStream::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind,
                              bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kTokenStreamCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the length field and the token stream.
   RawExternalTypedData* stream = ptr()->stream_;
   intptr_t len = Smi::Value(stream->ptr()->length_);
   writer->Write<RawObject*>(stream->ptr()->length_);
   writer->WriteBytes(stream->ptr()->data_, len);
 
   // Write out the literal/identifier token array.
   writer->WriteObjectImpl(ptr()->token_objects_, kAsInlinedObject);
   // Write out the private key in use by the token stream.
   writer->WriteObjectImpl(ptr()->private_key_, kAsInlinedObject);
 }
 
 
 RawScript* Script::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind,
                             bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Allocate script object.
   Script& script = Script::ZoneHandle(reader->zone(), NEW_OBJECT(Script));
   reader->AddBackRef(object_id, &script, kIsDeserialized);
 
   script.StoreNonPointer(&script.raw_ptr()->line_offset_,
                          reader->Read<int32_t>());
   script.StoreNonPointer(&script.raw_ptr()->col_offset_,
                          reader->Read<int32_t>());
   script.StoreNonPointer(&script.raw_ptr()->kind_,
                          reader->Read<int8_t>());
 
   *reader->StringHandle() ^= String::null();
   script.set_source(*reader->StringHandle());
   *reader->StreamHandle() ^= TokenStream::null();
   script.set_tokens(*reader->StreamHandle());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
-  RawObject** toobj = reader->snapshot_code()
-      ? script.raw()->to_precompiled_snapshot()
-      : script.raw()->to_snapshot();
-  intptr_t num_flds = (toobj - script.raw()->from());
+  intptr_t num_flds = (script.raw()->to_snapshot(kind) - script.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     script.StorePointer((script.raw()->from() + i),
                         reader->PassiveObjectHandle()->raw());
   }
 
   return script.raw();
 }
 
 
 void RawScript::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind,
                         bool as_reference) {
   ASSERT(writer != NULL);
   ASSERT(tokens_ != TokenStream::null());
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kScriptCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the non object fields.
   writer->Write<int32_t>(ptr()->line_offset_);
   writer->Write<int32_t>(ptr()->col_offset_);
   writer->Write<int8_t>(ptr()->kind_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer, kAsReference);
-  RawObject** toobj = writer->snapshot_code() ? to_precompiled_snapshot()
-                                              : to_snapshot();
-  visitor.VisitPointers(from(), toobj);
+  visitor.VisitPointers(from(), to_snapshot(kind));
 }
 
 
 RawLibrary* Library::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind,
                               bool as_reference) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage);
@@ skipping 17 matching lines @@
     library.StoreNonPointer(&library.raw_ptr()->num_imports_,
                             reader->Read<uint16_t>());
     library.StoreNonPointer(&library.raw_ptr()->load_state_,
                             reader->Read<int8_t>());
     library.StoreNonPointer(&library.raw_ptr()->corelib_imported_,
                             reader->Read<bool>());
     library.StoreNonPointer(&library.raw_ptr()->is_dart_scheme_,
                             reader->Read<bool>());
     library.StoreNonPointer(&library.raw_ptr()->debuggable_,
                             reader->Read<bool>());
-    if (kind == Snapshot::kFull) {
+    if (Snapshot::IsFull(kind)) {
       is_in_fullsnapshot = true;
     }
     library.StoreNonPointer(&library.raw_ptr()->is_in_fullsnapshot_,
                             is_in_fullsnapshot);
     // The native resolver and symbolizer are not serialized.
     library.set_native_entry_resolver(NULL);
     library.set_native_entry_symbol_resolver(NULL);
 
     // Set all the object fields.
     // TODO(5411462): Need to assert No GC can happen here, even though
     // allocations may happen.
     intptr_t num_flds = (library.raw()->to_snapshot() - library.raw()->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
       (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
       library.StorePointer((library.raw()->from() + i),
                            reader->PassiveObjectHandle()->raw());
     }
     // Initialize cache of resolved names.
     const intptr_t kInitialNameCacheSize = 64;
-    if (kind != Snapshot::kFull) {
+    if (!Snapshot::IsFull(kind)) {
       // The cache of resolved names in library scope is not serialized.
       library.InitResolvedNamesCache(kInitialNameCacheSize);
       library.Register();
     } else {
       library.InitResolvedNamesCache(kInitialNameCacheSize, reader);
     }
     library.StorePointer(&library.raw_ptr()->exported_names_, Array::null());
     // Initialize cache of loaded scripts.
     library.StorePointer(&library.raw_ptr()->loaded_scripts_, Array::null());
   }
@@ skipping 17 matching lines @@
 
   // Write out the boolean is_in_fullsnapshot_ first as this will
   // help the reader decide how the rest of the information needs
   // to be interpreted.
   writer->Write<bool>(ptr()->is_in_fullsnapshot_);
 
   if ((kind == Snapshot::kScript) && ptr()->is_in_fullsnapshot_) {
     // Write out library URL so that it can be looked up when reading.
     writer->WriteObjectImpl(ptr()->url_, kAsInlinedObject);
   } else {
-    ASSERT((kind == Snapshot::kFull) || !ptr()->is_in_fullsnapshot_);
+    ASSERT((Snapshot::IsFull(kind)) || !ptr()->is_in_fullsnapshot_);
     // Write out all non object fields.
     ASSERT(ptr()->index_ != static_cast<classid_t>(-1));
     writer->WriteClassIDValue(ptr()->index_);
     writer->Write<uint16_t>(ptr()->num_imports_);
     writer->Write<int8_t>(ptr()->load_state_);
     writer->Write<bool>(ptr()->corelib_imported_);
     writer->Write<bool>(ptr()->is_dart_scheme_);
     writer->Write<bool>(ptr()->debuggable_);
     // We do not serialize the native resolver or symbolizer. These need to be
     // explicitly set after deserialization.
 
     // We do not write the loaded_scripts_ and resolved_names_ caches to the
     // snapshot. They get initialized when reading the library from the
     // snapshot and will be rebuilt lazily.
     // Write out all the object pointer fields.
     SnapshotWriterVisitor visitor(writer, kAsReference);
     visitor.VisitPointers(from(), to_snapshot());
   }
 }
 
 
 RawLibraryPrefix* LibraryPrefix::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Allocate library prefix object.
   LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(
       reader->zone(), NEW_OBJECT(LibraryPrefix));
   reader->AddBackRef(object_id, &prefix, kIsDeserialized);
 
   // Set all non object fields.
   prefix.StoreNonPointer(&prefix.raw_ptr()->num_imports_,
                          reader->Read<int16_t>());
   prefix.StoreNonPointer(&prefix.raw_ptr()->is_deferred_load_,
                          reader->Read<bool>());
   prefix.StoreNonPointer(&prefix.raw_ptr()->is_loaded_, reader->Read<bool>());
 
   // Set all the object fields.
-  RawObject** toobj = reader->snapshot_code()
-      ? prefix.raw()->to_precompiled_snapshot()
-      : prefix.raw()->to();
   READ_OBJECT_FIELDS(prefix,
-                     prefix.raw()->from(), toobj,
+                     prefix.raw()->from(),
+                     prefix.raw()->to_snapshot(kind),
                      kAsReference);
-  if (reader->snapshot_code()) {
+  if (Snapshot::IncludesCode(kind)) {
     prefix.StorePointer(&prefix.raw_ptr()->imports_,
                         Array::null());
     prefix.StorePointer(&prefix.raw_ptr()->dependent_code_,
                         Array::null());
   }
 
   return prefix.raw();
 }
 
 
 void RawLibraryPrefix::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind,
                                bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(kLibraryPrefixCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all non object fields.
   writer->Write<int16_t>(ptr()->num_imports_);
   writer->Write<bool>(ptr()->is_deferred_load_);
   writer->Write<bool>(ptr()->is_loaded_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer, kAsReference);
-  RawObject** toobj = writer->snapshot_code() ? to_precompiled_snapshot()
-                                              : to();
-  visitor.VisitPointers(from(), toobj);
+  visitor.VisitPointers(from(), to_snapshot(kind));
 }
 
 
 RawNamespace* Namespace::ReadFrom(SnapshotReader* reader,
                                   intptr_t object_id,
                                   intptr_t tags,
                                   Snapshot::Kind kind,
                                   bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Allocate Namespace object.
   Namespace& ns = Namespace::ZoneHandle(
       reader->zone(), NEW_OBJECT(Namespace));
   reader->AddBackRef(object_id, &ns, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(ns, ns.raw()->from(), ns.raw()->to(), kAsReference);
 
   return ns.raw();
 }
 
 
 void RawNamespace::WriteTo(SnapshotWriter* writer,
                            intptr_t object_id,
                            Snapshot::Kind kind,
                            bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kNamespaceCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer, kAsReference);
@@ skipping 12 matching lines @@
   return sum;
 }
 #endif
 
 
 RawCode* Code::ReadFrom(SnapshotReader* reader,
                         intptr_t object_id,
                         intptr_t tags,
                         Snapshot::Kind kind,
                         bool as_reference) {
-  ASSERT(reader->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   Code& result = Code::ZoneHandle(reader->zone(), NEW_OBJECT_WITH_LEN(Code, 0));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   result.set_compile_timestamp(0);
   result.set_state_bits(reader->Read<int32_t>());
   result.set_lazy_deopt_pc_offset(-1);
 
   int32_t text_offset = reader->Read<int32_t>();
   int32_t instructions_size = reader->Read<int32_t>();
@@ skipping 57 matching lines @@
   ASSERT(result.EntryPoint() == entry_point);
 
   return result.raw();
 }
 
 
 void RawCode::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind,
                       bool as_reference) {
-  ASSERT(writer->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   intptr_t pointer_offsets_length =
       Code::PtrOffBits::decode(ptr()->state_bits_);
   if (pointer_offsets_length != 0) {
     // Should only be IA32.
     FATAL("Cannot serialize code with embedded pointers");
   }
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
@@ skipping 41 matching lines @@
                               bool as_reference) {
   UNREACHABLE();
 }
 
 
 RawObjectPool* ObjectPool::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind,
                                     bool as_reference) {
-  ASSERT(reader->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   intptr_t len = reader->Read<intptr_t>();
   ObjectPool* result = NULL;
   DeserializeState state;
   if (!as_reference) {
     result = reinterpret_cast<ObjectPool*>(reader->GetBackRef(object_id));
     state = kIsDeserialized;
   } else {
     state = kIsNotDeserialized;
   }
@@ skipping 41 matching lines @@
     }
   }
   return result->raw();
 }
 
 
 void RawObjectPool::WriteTo(SnapshotWriter* writer,
                             intptr_t object_id,
                             Snapshot::Kind kind,
                             bool as_reference) {
-  ASSERT(writer->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
   intptr_t tags = writer->GetObjectTags(this);
   intptr_t length = ptr()->length_;
 
   if (as_reference) {
     // Write out the serialization header value for this object.
     writer->WriteInlinedObjectHeader(kOmittedObjectId);
 
     // Write out the class information.
     writer->WriteVMIsolateObject(kObjectPoolCid);
     writer->WriteTags(tags);
@@ skipping 48 matching lines @@
     }
   }
 }
 
 
 RawPcDescriptors* PcDescriptors::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
-  ASSERT(reader->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   intptr_t offset = reader->Read<int32_t>();
   PcDescriptors& result = PcDescriptors::ZoneHandle(reader->zone());
   result ^= reader->GetObjectAt(offset);
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   return result.raw();
 }
 
 
 void RawPcDescriptors::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind,
                                bool as_reference) {
-  ASSERT(writer->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
   writer->WriteIndexedObject(kPcDescriptorsCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   writer->Write<int32_t>(writer->GetObjectId(this));
 }
 
 
 RawCodeSourceMap* CodeSourceMap::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
-  ASSERT(reader->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   const int32_t length = reader->Read<int32_t>();
   CodeSourceMap& result =
       CodeSourceMap::ZoneHandle(reader->zone(),
                                 NEW_OBJECT_WITH_LEN(CodeSourceMap, length));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   if (result.Length() > 0) {
     NoSafepointScope no_safepoint;
     intptr_t len = result.Length();
     uint8_t* data = result.UnsafeMutableNonPointer(result.raw_ptr()->data());
     reader->ReadBytes(data, len);
   }
 
   return result.raw();
 }
 
 
 void RawCodeSourceMap::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind,
                                bool as_reference) {
-  ASSERT(writer->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
   writer->WriteIndexedObject(kCodeSourceMapCid);
   writer->WriteTags(writer->GetObjectTags(this));
   writer->Write<int32_t>(ptr()->length_);
   if (ptr()->length_ > 0) {
     intptr_t len = ptr()->length_;
     uint8_t* data = reinterpret_cast<uint8_t*>(ptr()->data());
     writer->WriteBytes(data, len);
   }
 }
 
 
 RawStackmap* Stackmap::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind,
                                 bool as_reference) {
-  ASSERT(reader->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   intptr_t offset = reader->Read<int32_t>();
   Stackmap& result = Stackmap::ZoneHandle(reader->zone());
   result ^= reader->GetObjectAt(offset);
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   return result.raw();
 }
 
 
 void RawStackmap::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind,
                           bool as_reference) {
-  ASSERT(writer->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
   writer->WriteIndexedObject(kStackmapCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   writer->Write<int32_t>(writer->GetObjectId(this));
 }
 
 
 RawLocalVarDescriptors* LocalVarDescriptors::ReadFrom(SnapshotReader* reader,
                                                       intptr_t object_id,
                                                       intptr_t tags,
                                                       Snapshot::Kind kind,
                                                       bool as_reference) {
-  ASSERT(reader->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   const int32_t num_entries = reader->Read<int32_t>();
 
   LocalVarDescriptors& result =
       LocalVarDescriptors::ZoneHandle(reader->zone(),
                                       NEW_OBJECT_WITH_LEN(LocalVarDescriptors,
                                                           num_entries));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   for (intptr_t i = 0; i < num_entries; i++) {
@@ skipping 11 matching lines @@
   }
 
   return result.raw();
 }
 
 
 void RawLocalVarDescriptors::WriteTo(SnapshotWriter* writer,
                                      intptr_t object_id,
                                      Snapshot::Kind kind,
                                      bool as_reference) {
-  ASSERT(writer->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
   writer->WriteIndexedObject(kLocalVarDescriptorsCid);
   writer->WriteTags(writer->GetObjectTags(this));
   writer->Write<int32_t>(ptr()->num_entries_);
   for (intptr_t i = 0; i < ptr()->num_entries_; i++) {
     writer->WriteObjectImpl(ptr()->names()[i], kAsReference);
   }
   if (ptr()->num_entries_ > 0) {
     intptr_t len = ptr()->num_entries_ * sizeof(VarInfo);
     uint8_t* data = reinterpret_cast<uint8_t*>(this->data());
     writer->WriteBytes(data, len);
   }
 }
 
 
 RawExceptionHandlers* ExceptionHandlers::ReadFrom(SnapshotReader* reader,
                                                   intptr_t object_id,
                                                   intptr_t tags,
                                                   Snapshot::Kind kind,
                                                   bool as_reference) {
-  ASSERT(reader->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   const int32_t num_entries = reader->Read<int32_t>();
   ExceptionHandlers& result =
       ExceptionHandlers::ZoneHandle(reader->zone(),
                                     NEW_OBJECT_WITH_LEN(ExceptionHandlers,
                                                         num_entries));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   if (result.num_entries() > 0) {
     NoSafepointScope no_safepoint;
     const intptr_t len =
         result.num_entries() * sizeof(RawExceptionHandlers::HandlerInfo);
     uint8_t* data = result.UnsafeMutableNonPointer(
         reinterpret_cast<const uint8_t*>(result.raw_ptr()->data()));
     reader->ReadBytes(data, len);
   }
 
   *(reader->ArrayHandle()) ^= reader->ReadObjectImpl(kAsInlinedObject);
   result.StorePointer(&result.raw_ptr()->handled_types_data_,
                       reader->ArrayHandle()->raw());
 
   return result.raw();
 }
 
 
 void RawExceptionHandlers::WriteTo(SnapshotWriter* writer,
                                    intptr_t object_id,
                                    Snapshot::Kind kind,
                                    bool as_reference) {
-  ASSERT(writer->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
   writer->WriteIndexedObject(kExceptionHandlersCid);
   writer->WriteTags(writer->GetObjectTags(this));
   writer->Write<int32_t>(ptr()->num_entries_);
 
   if (ptr()->num_entries_ > 0) {
     intptr_t len = ptr()->num_entries_ * sizeof(HandlerInfo);
     uint8_t* data = reinterpret_cast<uint8_t*>(ptr()->data());
@@ skipping 62 matching lines @@
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind,
                                         bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate context object.
   bool is_implicit = reader->Read<bool>();
   if (is_implicit) {
     ContextScope& context_scope = ContextScope::ZoneHandle();
-    if (kind == Snapshot::kFull) {
+    if (Snapshot::IsFull(kind)) {
       context_scope = reader->NewContextScope(1);
       context_scope.set_is_implicit(true);
     } else {
       context_scope = ContextScope::New(1, true);
     }
     reader->AddBackRef(object_id, &context_scope, kIsDeserialized);
 
     *reader->TypeHandle() ^= reader->ReadObjectImpl(kAsInlinedObject);
 
     // Create a descriptor for 'this' variable.
@@ skipping 38 matching lines @@
   }
   UNREACHABLE();
 }
 
 
 RawICData* ICData::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind,
                             bool as_reference) {
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   ICData& result = ICData::ZoneHandle(reader->zone(), NEW_OBJECT(ICData));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   result.set_deopt_id(reader->Read<int32_t>());
   result.set_state_bits(reader->Read<uint32_t>());
 #if defined(TAG_IC_DATA)
   result.set_tag(reader->Read<int16_t>());
 #endif
 
   // Set all the object fields.
-  RawObject** toobj = reader->snapshot_code()
-      ? result.raw()->to_precompiled_snapshot()
-      : result.raw()->to();
   READ_OBJECT_FIELDS(result,
-                     result.raw()->from(), toobj,
+                     result.raw()->from(),
+                     result.raw()->to_snapshot(kind),
                      kAsReference);
-  if (reader->snapshot_code()) {
+  if (kind == Snapshot::kAppNoJIT) {
     result.set_owner(Function::Handle(reader->zone()));
   }
 
   return result.raw();
 }
 
 
 void RawICData::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind,
                         bool as_reference) {
-  ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
+  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kICDataCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the non object fields.
   writer->Write<int32_t>(ptr()->deopt_id_);
   writer->Write<uint32_t>(ptr()->state_bits_);
 #if defined(TAG_IC_DATA)
   writer->Write<int16_t>(ptr()->tag_);
 #endif
 
   // Write out all the object pointer fields.
   // In precompiled snapshots, omit the owner field. The owner field may
   // refer to a function which was always inlined and no longer needed.
   SnapshotWriterVisitor visitor(writer, kAsReference);
-  RawObject** toobj = writer->snapshot_code() ? to_precompiled_snapshot()
-                                              : to();
-  visitor.VisitPointers(from(), toobj);
+  visitor.VisitPointers(from(), to_snapshot(kind));
 }
 
 
 RawMegamorphicCache* MegamorphicCache::ReadFrom(SnapshotReader* reader,
                                                 intptr_t object_id,
                                                 intptr_t tags,
                                                 Snapshot::Kind kind,
                                                 bool as_reference) {
-  ASSERT(reader->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   MegamorphicCache& result =
       MegamorphicCache::ZoneHandle(reader->zone(),
                                    NEW_OBJECT(MegamorphicCache));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   result.set_filled_entry_count(reader->Read<int32_t>());
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(result,
                      result.raw()->from(), result.raw()->to(),
                      kAsReference);
 
   return result.raw();
 }
 
 
 void RawMegamorphicCache::WriteTo(SnapshotWriter* writer,
                                   intptr_t object_id,
                                   Snapshot::Kind kind,
                                   bool as_reference) {
-  ASSERT(writer->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kMegamorphicCacheCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the non object fields.
   writer->Write<int32_t>(ptr()->filled_entry_count_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer, kAsReference);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawSubtypeTestCache* SubtypeTestCache::ReadFrom(SnapshotReader* reader,
                                                 intptr_t object_id,
                                                 intptr_t tags,
                                                 Snapshot::Kind kind,
                                                 bool as_reference) {
-  ASSERT(reader->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   SubtypeTestCache& result =
       SubtypeTestCache::ZoneHandle(reader->zone(),
                                    NEW_OBJECT(SubtypeTestCache));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   (*reader->ArrayHandle()) ^= reader->ReadObjectImpl(kAsReference);
   result.StorePointer(&result.raw_ptr()->cache_,
                       reader->ArrayHandle()->raw());
 
   return result.raw();
 }
 
 
 void RawSubtypeTestCache::WriteTo(SnapshotWriter* writer,
                                   intptr_t object_id,
                                   Snapshot::Kind kind,
                                   bool as_reference) {
-  ASSERT(writer->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
+  ASSERT(Snapshot::IncludesCode(kind));
+  ASSERT(Snapshot::IsFull(kind));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kSubtypeTestCacheCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the object pointer fields.
   writer->WriteObjectImpl(ptr()->cache_, kAsReference);
@@ skipping 164 matching lines @@
 RawInstance* Instance::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind,
                                 bool as_reference) {
   ASSERT(reader != NULL);
 
   // Create an Instance object or get canonical one if it is a canonical
   // constant.
   Instance& obj = Instance::ZoneHandle(reader->zone(), Instance::null());
-  if (kind == Snapshot::kFull) {
+  if (Snapshot::IsFull(kind)) {
     obj = reader->NewInstance();
     // Set the canonical bit.
     if (RawObject::IsCanonical(tags)) {
       obj.SetCanonical();
     }
   } else {
     obj ^= Object::Allocate(kInstanceCid,
                             Instance::InstanceSize(),
                             HEAP_SPACE(kind));
     if (RawObject::IsCanonical(tags)) {
@@ skipping 35 matching lines @@
   // architecture, if so return the object as a Smi.
   if (Smi::IsValid(value)) {
     Smi& smi = Smi::ZoneHandle(reader->zone(),
                                Smi::New(static_cast<intptr_t>(value)));
     reader->AddBackRef(object_id, &smi, kIsDeserialized);
     return smi.raw();
   }
 
   // Create a Mint object or get canonical one if it is a canonical constant.
   Mint& mint = Mint::ZoneHandle(reader->zone(), Mint::null());
-  if (kind == Snapshot::kFull) {
+  if (Snapshot::IsFull(kind)) {
     mint = reader->NewMint(value);
     // Set the canonical bit.
     if (RawObject::IsCanonical(tags)) {
       mint.SetCanonical();
     }
   } else {
     // When reading a script snapshot we need to canonicalize only those object
     // references that are objects from the core library (loaded from a
     // full snapshot). Objects that are only in the script need not be
     // canonicalized as they are already canonical.
@@ skipping 41 matching lines @@
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(obj, obj.raw()->from(), obj.raw()->to(), kAsInlinedObject);
 
   // If it is a canonical constant make it one.
   // When reading a full snapshot we don't need to canonicalize the object
   // as it would already be a canonical object.
   // When reading a script snapshot or a message snapshot we always have
   // to canonicalize the object.
   if (RawObject::IsCanonical(tags)) {
-    if (kind == Snapshot::kFull) {
+    if (Snapshot::IsFull(kind)) {
       // Set the canonical bit.
       obj.SetCanonical();
     } else {
       obj ^= obj.CheckAndCanonicalize(reader->thread(), NULL);
       ASSERT(!obj.IsNull());
       ASSERT(obj.IsCanonical());
     }
   }
   return obj.raw();
 }
@@ skipping 23 matching lines @@
                             intptr_t tags,
                             Snapshot::Kind kind,
                             bool as_reference) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage);
   // Read the double value for the object.
   double value = reader->ReadDouble();
 
   // Create a Double object or get canonical one if it is a canonical constant.
   Double& dbl = Double::ZoneHandle(reader->zone(), Double::null());
-  if (kind == Snapshot::kFull) {
+  if (Snapshot::IsFull(kind)) {
     dbl = reader->NewDouble(value);
     // Set the canonical bit.
     if (RawObject::IsCanonical(tags)) {
       dbl.SetCanonical();
     }
   } else {
     // When reading a script snapshot we need to canonicalize only those object
     // references that are objects from the core library (loaded from a
     // full snapshot). Objects that are only in the script need not be
     // canonicalized as they are already canonical.
@@ skipping 76 matching lines @@
     }
   }
 }
 
 
 RawOneByteString* OneByteString::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
-  if (reader->snapshot_code()) {
-    ASSERT(kind == Snapshot::kFull);
+  if (Snapshot::IncludesCode(kind)) {
+    ASSERT(Snapshot::IsFull(kind));
     intptr_t offset = reader->Read<int32_t>();
     String& result = String::ZoneHandle(reader->zone());
     result ^= reader->GetObjectAt(offset);
     reader->AddBackRef(object_id, &result, kIsDeserialized);
     return raw(result);
   }
   // Read the length so that we can determine instance size to allocate.
   ASSERT(reader != NULL);
   intptr_t len = reader->ReadSmiValue();
   intptr_t hash = reader->ReadSmiValue();
   String& str_obj = String::ZoneHandle(reader->zone(), String::null());
 
-  if (kind == Snapshot::kFull) {
+  if (Snapshot::IsFull(kind)) {
     // We currently only expect the Dart mutator to read snapshots.
     reader->isolate()->AssertCurrentThreadIsMutator();
     ASSERT(Thread::Current()->no_safepoint_scope_depth() != 0);
     RawOneByteString* obj = reader->NewOneByteString(len);
     str_obj = obj;
     if (RawObject::IsCanonical(tags)) {
       str_obj.SetCanonical();
     }
     str_obj.SetHash(hash);
     if (len > 0) {
@@ skipping 14 matching lines @@
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
   // Read the length so that we can determine instance size to allocate.
   ASSERT(reader != NULL);
   intptr_t len = reader->ReadSmiValue();
   intptr_t hash = reader->ReadSmiValue();
   String& str_obj = String::ZoneHandle(reader->zone(), String::null());
 
-  if (kind == Snapshot::kFull) {
+  if (Snapshot::IsFull(kind)) {
     RawTwoByteString* obj = reader->NewTwoByteString(len);
     str_obj = obj;
     if (RawObject::IsCanonical(tags)) {
       str_obj.SetCanonical();
     }
     str_obj.SetHash(hash);
     NoSafepointScope no_safepoint;
     uint16_t* raw_ptr = (len > 0)? CharAddr(str_obj, 0) : NULL;
     for (intptr_t i = 0; i < len; i++) {
       ASSERT(CharAddr(str_obj, i) == raw_ptr);  // Will trigger assertions.
@@ skipping 45 matching lines @@
       }
     }
   }
 }
 
 
 void RawOneByteString::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind,
                                bool as_reference) {
-  if (writer->snapshot_code()) {
-    ASSERT(writer->snapshot_code());
-    ASSERT(kind == Snapshot::kFull);
+  if (Snapshot::IncludesCode(kind)) {
+    ASSERT(Snapshot::IncludesCode(kind));
+    ASSERT(Snapshot::IsFull(kind));
     // Assert that hash is computed.
     if (ptr()->hash_ == NULL) {
       ptr()->hash_ = Smi::New(String::Hash(ptr()->data(),
                                            Smi::Value(ptr()->length_)));
     }
     ASSERT(ptr()->hash_ != NULL);
     // Write out the serialization header value for this object.
     writer->WriteInlinedObjectHeader(object_id);
     writer->WriteIndexedObject(kOneByteStringCid);
     writer->WriteTags(writer->GetObjectTags(this));
@@ skipping 149 matching lines @@
   if (array == NULL) {
     array = &(Array::ZoneHandle(
         reader->zone(),
         NEW_OBJECT_WITH_LEN_SPACE(ImmutableArray, len, kind)));
     reader->AddBackRef(object_id, array, state);
   }
   if (!as_reference) {
     // Read all the individual elements for inlined objects.
     reader->ArrayReadFrom(object_id, *array, len, tags);
     if (RawObject::IsCanonical(tags)) {
-      if (kind == Snapshot::kFull) {
+      if (Snapshot::IsFull(kind)) {
         array->SetCanonical();
       } else {
         *array ^= array->CheckAndCanonicalize(reader->thread(), NULL);
       }
     }
   }
   return raw(*array);
 }
 
 
@@ skipping 29 matching lines @@
 RawGrowableObjectArray* GrowableObjectArray::ReadFrom(SnapshotReader* reader,
                                                       intptr_t object_id,
                                                       intptr_t tags,
                                                       Snapshot::Kind kind,
                                                       bool as_reference) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
   GrowableObjectArray& array = GrowableObjectArray::ZoneHandle(
       reader->zone(), GrowableObjectArray::null());
-  if (kind == Snapshot::kFull) {
+  if (Snapshot::IsFull(kind)) {
     array = reader->NewGrowableObjectArray();
   } else {
     array = GrowableObjectArray::New(0, HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &array, kIsDeserialized);
 
   // Read type arguments of growable array object.
   const intptr_t typeargs_offset =
       GrowableObjectArray::type_arguments_offset() / kWordSize;
   *reader->TypeArgumentsHandle() ^=
@@ skipping 38 matching lines @@
 
 RawLinkedHashMap* LinkedHashMap::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
   ASSERT(reader != NULL);
 
   LinkedHashMap& map = LinkedHashMap::ZoneHandle(
       reader->zone(), LinkedHashMap::null());
-  if ((kind == Snapshot::kFull && !reader->snapshot_code()) ||
+  if ((Snapshot::IsFull(kind) && !Snapshot::IncludesCode(kind)) ||
       kind == Snapshot::kScript) {
     // The immutable maps that seed map literals are not yet VM-internal, so
     // we don't reach this.
     UNREACHABLE();
   } else {
     // Since the map might contain itself as a key or value, allocate first.
-    if (kind == Snapshot::kFull) {
+    if (Snapshot::IsFull(kind)) {
       map = reader->NewLinkedHashMap();
     } else {
       map = LinkedHashMap::NewUninitialized(HEAP_SPACE(kind));
     }
   }
   reader->AddBackRef(object_id, &map, kIsDeserialized);
 
   // Read the type arguments.
   const intptr_t typeargs_offset =
       GrowableObjectArray::type_arguments_offset() / kWordSize;
@@ skipping 31 matching lines @@
     data.SetAt(i, *reader->PassiveObjectHandle());
   }
   return map.raw();
 }
 
 
 void RawLinkedHashMap::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind,
                                bool as_reference) {
-  if ((kind == Snapshot::kFull && !writer->snapshot_code()) ||
+  if ((Snapshot::IsFull(kind) && !Snapshot::IncludesCode(kind)) ||
       kind == Snapshot::kScript) {
     // The immutable maps that seed map literals are not yet VM-internal, so
     // we don't reach this.
   }
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
@@ skipping 42 matching lines @@
   ASSERT(reader != NULL);
   // Read the values.
   float value0 = reader->Read<float>();
   float value1 = reader->Read<float>();
   float value2 = reader->Read<float>();
   float value3 = reader->Read<float>();
 
   // Create a Float32x4 object.
   Float32x4& simd = Float32x4::ZoneHandle(reader->zone(),
                                           Float32x4::null());
-  if (kind == Snapshot::kFull) {
+  if (Snapshot::IsFull(kind)) {
     simd = reader->NewFloat32x4(value0, value1, value2, value3);
   } else {
     simd = Float32x4::New(value0, value1, value2, value3, HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &simd, kIsDeserialized);
   return simd.raw();
 }
 
 
 void RawFloat32x4::WriteTo(SnapshotWriter* writer,
@@ skipping 25 matching lines @@
   ASSERT(reader != NULL);
   // Read the values.
   uint32_t value0 = reader->Read<uint32_t>();
   uint32_t value1 = reader->Read<uint32_t>();
   uint32_t value2 = reader->Read<uint32_t>();
   uint32_t value3 = reader->Read<uint32_t>();
 
   // Create a Float32x4 object.
   Int32x4& simd = Int32x4::ZoneHandle(reader->zone(), Int32x4::null());
 
-  if (kind == Snapshot::kFull) {
+  if (Snapshot::IsFull(kind)) {
     simd = reader->NewInt32x4(value0, value1, value2, value3);
   } else {
     simd = Int32x4::New(value0, value1, value2, value3, HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &simd, kIsDeserialized);
   return simd.raw();
 }
 
 
 void RawInt32x4::WriteTo(SnapshotWriter* writer,
@@ skipping 23 matching lines @@
                                   Snapshot::Kind kind,
                                   bool as_reference) {
   ASSERT(reader != NULL);
   // Read the values.
   double value0 = reader->Read<double>();
   double value1 = reader->Read<double>();
 
   // Create a Float64x2 object.
   Float64x2& simd = Float64x2::ZoneHandle(reader->zone(),
                                           Float64x2::null());
-  if (kind == Snapshot::kFull) {
+  if (Snapshot::IsFull(kind)) {
     simd = reader->NewFloat64x2(value0, value1);
   } else {
     simd = Float64x2::New(value0, value1, HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &simd, kIsDeserialized);
   return simd.raw();
 }
 
 
 void RawFloat64x2::WriteTo(SnapshotWriter* writer,
@@ skipping 24 matching lines @@
 RawTypedData* TypedData::ReadFrom(SnapshotReader* reader,
                                   intptr_t object_id,
                                   intptr_t tags,
                                   Snapshot::Kind kind,
                                   bool as_reference) {
   ASSERT(reader != NULL);
 
   intptr_t cid = RawObject::ClassIdTag::decode(tags);
   intptr_t len = reader->ReadSmiValue();
   TypedData& result = TypedData::ZoneHandle(reader->zone(),
-      (kind == Snapshot::kFull) ? reader->NewTypedData(cid, len)
+      (Snapshot::IsFull(kind)) ? reader->NewTypedData(cid, len)
                                 : TypedData::New(cid, len, HEAP_SPACE(kind)));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   // Setup the array elements.
   intptr_t element_size = ElementSizeInBytes(cid);
   intptr_t length_in_bytes = len * element_size;
   switch (cid) {
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid: {
@@ skipping 28 matching lines @@
       break;
     default:
       UNREACHABLE();
   }
   // If it is a canonical constant make it one.
   // When reading a full snapshot we don't need to canonicalize the object
   // as it would already be a canonical object.
   // When reading a script snapshot or a message snapshot we always have
   // to canonicalize the object.
   if (RawObject::IsCanonical(tags)) {
-    if (kind == Snapshot::kFull) {
+    if (Snapshot::IsFull(kind)) {
       // Set the canonical bit.
       result.SetCanonical();
     } else {
       result ^= result.CheckAndCanonicalize(reader->thread(), NULL);
       ASSERT(!result.IsNull());
       ASSERT(result.IsCanonical());
     }
   }
   return result.raw();
 }
 #undef TYPED_DATA_READ
 
 
 RawExternalTypedData* ExternalTypedData::ReadFrom(SnapshotReader* reader,
                                                   intptr_t object_id,
                                                   intptr_t tags,
                                                   Snapshot::Kind kind,
                                                   bool as_reference) {
-  ASSERT(kind != Snapshot::kFull);
+  ASSERT(!Snapshot::IsFull(kind));
   intptr_t cid = RawObject::ClassIdTag::decode(tags);
   intptr_t length = reader->ReadSmiValue();
   uint8_t* data = reinterpret_cast<uint8_t*>(reader->ReadRawPointerValue());
   ExternalTypedData& obj = ExternalTypedData::ZoneHandle(
       ExternalTypedData::New(cid, data, length));
   reader->AddBackRef(object_id, &obj, kIsDeserialized);
   void* peer = reinterpret_cast<void*>(reader->ReadRawPointerValue());
   Dart_WeakPersistentHandleFinalizer callback =
       reinterpret_cast<Dart_WeakPersistentHandleFinalizer>(
           reader->ReadRawPointerValue());
@@ skipping 189 matching lines @@
     UNREACHABLE();
   }
 }
 
 
 RawSendPort* SendPort::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind,
                                 bool as_reference) {
-  ASSERT(kind == Snapshot::kMessage || reader->snapshot_code());
+  ASSERT(kind == Snapshot::kMessage || Snapshot::IncludesCode(kind));
 
   uint64_t id = reader->Read<uint64_t>();
   uint64_t origin_id = reader->Read<uint64_t>();
 
   SendPort& result = SendPort::ZoneHandle(reader->zone());
-  if (reader->snapshot_code()) {
+  if (Snapshot::IncludesCode(kind)) {
     // TODO(rmacnak): Reset fields in precompiled snapshots and assert
     // this is unreachable.
   } else {
     result = SendPort::New(id, origin_id);
   }
   reader->AddBackRef(object_id, &result, kIsDeserialized);
   return result.raw();
 }
 
 
@@ skipping 11 matching lines @@
   writer->Write<uint64_t>(ptr()->id_);
   writer->Write<uint64_t>(ptr()->origin_id_);
 }
 
 
 RawStacktrace* Stacktrace::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind,
                                     bool as_reference) {
-  if (kind == Snapshot::kFull) {
+  if (Snapshot::IsFull(kind)) {
     Stacktrace& result = Stacktrace::ZoneHandle(reader->zone(),
                                                 reader->NewStacktrace());
     reader->AddBackRef(object_id, &result, kIsDeserialized);
 
     bool expand_inlined = reader->Read<bool>();
     result.set_expand_inlined(expand_inlined);
 
     // Set all the object fields.
     READ_OBJECT_FIELDS(result,
                        result.raw()->from(), result.raw()->to(),
                        kAsReference);
 
     return result.raw();
   }
   UNREACHABLE();  // Stacktraces are not sent in a snapshot.
   return Stacktrace::null();
 }
 
 
 void RawStacktrace::WriteTo(SnapshotWriter* writer,
                             intptr_t object_id,
                             Snapshot::Kind kind,
                             bool as_reference) {
-  if (kind == Snapshot::kFull) {
+  if (Snapshot::IsFull(kind)) {
     ASSERT(writer != NULL);
     ASSERT(this == Isolate::Current()->object_store()->
            preallocated_stack_trace());
 
     // Write out the serialization header value for this object.
     writer->WriteInlinedObjectHeader(object_id);
 
     // Write out the class and tags information.
     writer->WriteIndexedObject(kStacktraceCid);
     writer->WriteTags(writer->GetObjectTags(this));
@@ skipping 152 matching lines @@
     // We do not allow objects with native fields in an isolate message.
     writer->SetWriteException(Exceptions::kArgument,
                               "Illegal argument in isolate message"
                               " : (object is a UserTag)");
   } else {
     UNREACHABLE();
   }
 }
 
 }  // namespace dart