Changes to set up the object tag bits

vm/snapshot.cc

 // Copyright (c) 2011, 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 "vm/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/heap.h"
 #include "vm/object.h"
@@ skipping 152 matching lines @@
   ASSERT(object_id >= kMaxPredefinedObjectIds);
   intptr_t index = object_id - kMaxPredefinedObjectIds;
   ASSERT(index < backward_references_.length());
   return backward_references_[index]->raw();
 }
 
 
 RawObject* SnapshotReader::ReadInlinedObject(intptr_t object_id) {
   // Read the class header information and lookup the class.
   intptr_t class_header = Read<intptr_t>();
+  intptr_t tags = Read<intptr_t>();
   Class& cls = Class::Handle();
+  Object& obj = Object::Handle();
   if (SerializedHeaderData::decode(class_header) == kInstanceId) {
     // Object is regular dart instance.
     Instance& result = Instance::ZoneHandle();
     AddBackwardReference(object_id, &result);
 
     cls ^= ReadObject();
     ASSERT(!cls.IsNull());
     intptr_t instance_size = cls.instance_size();
     ASSERT(instance_size > 0);
     // Allocate the instance and read in all the fields for the object.
     RawObject* raw = Object::Allocate(cls, instance_size, Heap::kNew);
     result ^= raw;
     intptr_t offset = Object::InstanceSize();
-    Object& obj = Object::Handle();
     while (offset < instance_size) {
       obj = ReadObject();
       result.SetFieldAtOffset(offset, obj);
       offset += kWordSize;
     }
+    if (kind_ == Snapshot::kFull) {
+      result.SetCreatedFromSnapshot();
+    }
     return result.raw();
   } else {
     ASSERT((class_header & kSmiTagMask) != 0);
     cls ^= LookupInternalClass(class_header);
     ASSERT(!cls.IsNull());
   }
   switch (cls.instance_kind()) {
 #define SNAPSHOT_READ(clazz)                                                   \
     case clazz::kInstanceKind: {                                               \
-      return clazz::ReadFrom(this, object_id, kind_);                          \
+      obj = clazz::ReadFrom(this, object_id, tags, kind_);                     \
+      break;                                                                   \
     }
     CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
 #undef SNAPSHOT_READ
-    default: break;
+    default: UNREACHABLE(); break;
   }
-  UNREACHABLE();
-  return Object::null();
+  if (kind_ == Snapshot::kFull) {
+    obj.SetCreatedFromSnapshot();
+  }
+  return obj.raw();
 }
 
 
 void MessageWriter::WriteMessage(intptr_t field_count, intptr_t *data) {
   // Write out the serialization header value for this object.
-  WriteObjectHeader(kInlined, kMaxPredefinedObjectIds);
+  WriteSerializationMarker(kInlined, kMaxPredefinedObjectIds);
 
-  // Write out the class information.
-  WriteObjectHeader(kObjectId, ObjectStore::kArrayClass);
+  // Write out the class and tags information.
+  WriteObjectHeader(ObjectStore::kArrayClass, 0);
 
   // Write out the length field.
   Write<RawObject*>(Smi::New(field_count));
 
   // Write out the type arguments.
-  WriteObjectHeader(kObjectId, Object::kNullObject);
+  WriteIndexedObject(Object::kNullObject);
 
   // Write out the individual Smis.
   for (int i = 0; i < field_count; i++) {
     Write<RawObject*>(Integer::New(data[i]));
   }
 
   FinalizeBuffer();
 }
 
 
@@ skipping 11 matching lines @@
   // writing a snap shot.
 
   // First check if it is a Smi (i.e not a heap object).
   if (!rawobj->IsHeapObject()) {
     Write<RawObject*>(rawobj);
     return;
   }
 
   // Check if it is a singleton null object which is shared by all isolates.
   if (rawobj == Object::null()) {
-    WriteObjectHeader(kObjectId, Object::kNullObject);
+    WriteIndexedObject(Object::kNullObject);
     return;
   }
 
   // Check if it is a singleton sentinel object which is shared by all isolates.
   if (rawobj == Object::sentinel()) {
-    WriteObjectHeader(kObjectId, Object::kSentinelObject);
+    WriteIndexedObject(Object::kSentinelObject);
     return;
   }
 
   // Check if it is a singleton class object which is shared by
   // all isolates.
   RawClass* raw_class = reinterpret_cast<RawClass*>(rawobj);
   intptr_t index = Object::GetSingletonClassIndex(raw_class);
   if (index != Object::kInvalidIndex) {
-    WriteObjectHeader(kObjectId, index);
+    WriteIndexedObject(index);
     return;
   }
 
   // Check if it is a singleton boolean true value.
   if (rawobj == object_store()->true_value()) {
-    WriteObjectHeader(kObjectId, ObjectStore::kTrueValue);
+    WriteIndexedObject(ObjectStore::kTrueValue);
     return;
   }
 
   // Check if it is a singleton boolean false value.
   if (rawobj == object_store()->false_value()) {
-    WriteObjectHeader(kObjectId, ObjectStore::kFalseValue);
+    WriteIndexedObject(ObjectStore::kFalseValue);
     return;
   }
 
   // Check if classes are not being serialized and it is preinitialized type.
   if (kind_ != Snapshot::kFull) {
     RawType* raw_type = reinterpret_cast<RawType*>(rawobj);
     index = object_store()->GetTypeIndex(raw_type);
     if (index != ObjectStore::kInvalidIndex) {
-      WriteObjectHeader(kObjectId, index);
+      WriteIndexedObject(index);
       return;
     }
   }
 
   // Now write the object out inline in the stream.
   WriteInlinedObject(rawobj);
 }
 
 
-void SnapshotWriter::WriteObjectHeader(SerializedHeaderType type, intptr_t id) {
-  uword value = 0;
-  value = SerializedHeaderTag::update(type, value);
-  value = SerializedHeaderData::update(id, value);
-  Write<uword>(value);
-}
-
-
 void SnapshotWriter::UnmarkAll() {
   NoGCScope no_gc;
   for (intptr_t i = 0; i < forward_list_.length(); i++) {
     RawObject* raw = forward_list_[i]->raw();
     raw->ptr()->class_ = forward_list_[i]->cls();  // Restore original class.
   }
 }
 
 
 void SnapshotWriter::WriteFullSnapshot() {
@@ skipping 28 matching lines @@
 
 
 void SnapshotWriter::WriteInlinedObject(RawObject* raw) {
   NoGCScope no_gc;
   RawClass* cls = raw->ptr()->class_;
 
   // Check if object has already been serialized, in that
   // case just write the object id out.
   if (SerializedHeaderTag::decode(reinterpret_cast<uword>(cls)) == kObjectId) {
     intptr_t id = SerializedHeaderData::decode(reinterpret_cast<intptr_t>(cls));
-    WriteObjectHeader(kObjectId, id);
+    WriteIndexedObject(id);
     return;
   }
 
   // Object is being serialized, add it to the forward ref list and mark
   // it so that future references to this object in the snapshot will use
   // an object id, instead of trying to serialize it again.
   intptr_t object_id = MarkObject(raw, cls);
 
   ObjectKind kind = cls->ptr()->instance_kind_;
   if (kind == Instance::kInstanceKind) {
     // Object is regular dart instance.
     // TODO(5411462): figure out what we need to do if an object with native
     // fields is serialized (throw exception or serialize a null object).
     ASSERT(cls->ptr()->num_native_fields_ == 0);
     intptr_t instance_size = cls->ptr()->instance_size_;
     ASSERT(instance_size != 0);
 
     // Write out the serialization header value for this object.
-    WriteObjectHeader(kInlined, object_id);
+    WriteSerializationMarker(kInlined, object_id);
 
     // Indicate this is an instance object.
     Write<intptr_t>(SerializedHeaderData::encode(kInstanceId));
 
+    // Write out the tags.
+    Write<intptr_t>(raw->ptr()->tags_);
+
     // Write out the class information for this object.
     WriteObject(cls);
 
     // Write out all the fields for the object.
     intptr_t offset = Object::InstanceSize();
     while (offset < instance_size) {
       WriteObject(*reinterpret_cast<RawObject**>(
           reinterpret_cast<uword>(raw->ptr()) + offset));
       offset += kWordSize;
     }
@@ skipping 12 matching lines @@
     default: break;
   }
   UNREACHABLE();
 }
 
 
 void SnapshotWriter::WriteClassId(RawClass* cls) {
   ASSERT(kind_ != Snapshot::kFull);
   int id = object_store()->GetClassIndex(cls);
   if (IsSingletonClassId(id) || IsObjectStoreClassId(id)) {
-    WriteObjectHeader(kObjectId, id);
+    WriteIndexedObject(id);
   } else {
     // TODO(5411462): Should restrict this to only core-lib classes in this
     // case.
-    // Write out the class information.
-    WriteObjectHeader(kObjectId, Object::kClassClass);
+    // Write out the class and tags information.
+    WriteObjectHeader(Object::kClassClass, cls->ptr()->tags_);
     // Write out the library url and class name.
     RawLibrary* library = cls->ptr()->library_;
     ASSERT(library != Library::null());
     WriteObject(library->ptr()->url_);
     WriteObject(cls->ptr()->name_);
   }
 }
 
 
 void ScriptSnapshotWriter::WriteScriptSnapshot() {
   // TODO(asiva): Need to implement this.
   UNIMPLEMENTED();
 }
 
 
 void SnapshotWriterVisitor::VisitPointers(RawObject** first, RawObject** last) {
   for (RawObject** current = first; current <= last; current++) {
     RawObject* raw_obj = *current;
     writer_->WriteObject(raw_obj);
   }
 }
 
 }  // namespace dart