Refactor snapshot writing code in preparation for the change to remove recursive calls to WriteObje…

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/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/exceptions.h"
@@ skipping 456 matching lines @@
     default: UNREACHABLE(); break;
   }
   if (kind_ == Snapshot::kFull) {
     obj_.SetCreatedFromSnapshot();
   }
   return obj_.raw();
 }
 
 
 void SnapshotWriter::WriteObject(RawObject* rawobj) {
-  // An object is written in one of the following ways:
-  // - Smi: the Smi value is written as is (last bit is not tagged).
-  // - VM internal class (from VM isolate): (index of class in vm isolate | 0x3)
-  // - Object that has already been written: (negative id in stream | 0x3)
-  // - Object that is seen for the first time (inlined as follows):
+  // First check if object can be written as a simple predefined type.
+  if (CheckAndWritePredefinedObject(rawobj)) {
+    return;
+  }
+  // Now write the object out inline in the stream as follows:
+  // - Object is seen for the first time (inlined as follows):
   //    (object size in multiples of kObjectAlignment | 0x1)
   //    serialized fields of the object
   //    ......
-
-  NoGCScope no_gc;
-  // writing a snap shot.
-
-  // First check if it is a Smi (i.e not a heap object).
-  if (!rawobj->IsHeapObject()) {
-    Write<int64_t>(reinterpret_cast<intptr_t>(rawobj));
-    return;
-  }
-
-  // Check if it is a singleton null object which is shared by all isolates.
-  if (rawobj == Object::null()) {
-    WriteIndexedObject(Object::kNullObject);
-    return;
-  }
-
-  // Check if it is a singleton sentinel object which is shared by all isolates.
-  if (rawobj == Object::sentinel()) {
-    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) {
-    WriteIndexedObject(index);
-    return;
-  }
-
-  // Check if it is a singleton boolean true value.
-  if (rawobj == object_store()->true_value()) {
-    WriteIndexedObject(ObjectStore::kTrueValue);
-    return;
-  }
-
-  // Check if it is a singleton boolean false value.
-  if (rawobj == object_store()->false_value()) {
-    WriteIndexedObject(ObjectStore::kFalseValue);
-    return;
-  }
-
-  // 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 (RawObject::ClassIdTag::decode(GetObjectTags(rawobj)) == kCode) {
-    WriteIndexedObject(Object::kNullObject);
-    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) {
-      WriteIndexedObject(index);
-      return;
-    }
-  }
-
-  // Now write the object out inline in the stream.
   WriteInlinedObject(rawobj);
 }
 
 
 void SnapshotWriter::UnmarkAll() {
   NoGCScope no_gc;
   for (intptr_t i = 0; i < forward_list_.length(); i++) {
     RawObject* raw = forward_list_[i]->raw();
     raw->ptr()->tags_ = forward_list_[i]->tags();  // Restore original tags.
   }
@@ skipping 21 matching lines @@
   uword tags = raw->ptr()->tags_;
   if (SerializedHeaderTag::decode(tags) == kObjectId) {
     intptr_t id = SerializedHeaderData::decode(tags);
     return forward_list_[id - kMaxPredefinedObjectIds]->tags();
   } else {
     return tags;
   }
 }
 
 
-intptr_t SnapshotWriter::MarkObject(RawObject* raw, RawClass* cls) {
+intptr_t SnapshotWriter::MarkObject(RawObject* raw) {
   NoGCScope no_gc;
   intptr_t object_id = forward_list_.length() + kMaxPredefinedObjectIds;
   ASSERT(object_id <= kMaxObjectId);
   uword value = 0;
   value = SerializedHeaderTag::update(kObjectId, value);
   value = SerializedHeaderData::update(object_id, value);
   uword tags = raw->ptr()->tags_;
   raw->ptr()->tags_ = value;
   ForwardObjectNode* node = new ForwardObjectNode(raw, tags);
   ASSERT(node != NULL);
   forward_list_.Add(node);
   return object_id;
 }
 
 
+bool SnapshotWriter::CheckAndWritePredefinedObject(RawObject* rawobj) {
+  // Check if object can be written in one of the following ways:
+  // - Smi: the Smi value is written as is (last bit is not tagged).
+  // - VM internal class (from VM isolate): (index of class in vm isolate | 0x3)
+  // - Object that has already been written: (negative id in stream | 0x3)
+
+  NoGCScope no_gc;
+
+  // First check if it is a Smi (i.e not a heap object).
+  if (!rawobj->IsHeapObject()) {
+    Write<int64_t>(reinterpret_cast<intptr_t>(rawobj));
+    return true;
+  }
+
+  // Check if it is a singleton null object which is shared by all isolates.
+  if (rawobj == Object::null()) {
+    WriteIndexedObject(Object::kNullObject);
+    return true;
+  }
+
+  // Check if it is a singleton sentinel object which is shared by all isolates.
+  if (rawobj == Object::sentinel()) {
+    WriteIndexedObject(Object::kSentinelObject);
+    return true;
+  }
+
+  // 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) {
+    WriteIndexedObject(index);
+    return true;
+  }
+
+  // Check if it is a singleton boolean true value.
+  if (rawobj == object_store()->true_value()) {
+    WriteIndexedObject(ObjectStore::kTrueValue);
+    return true;
+  }
+
+  // Check if it is a singleton boolean false value.
+  if (rawobj == object_store()->false_value()) {
+    WriteIndexedObject(ObjectStore::kFalseValue);
+    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 (RawObject::ClassIdTag::decode(GetObjectTags(rawobj)) == kCode) {
+    WriteIndexedObject(Object::kNullObject);
+    return true;
+  }
+
+  // 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) {
+      WriteIndexedObject(index);
+      return true;
+    }
+  }
+
+  // Check if object has already been serialized, in that
+  // case just write the object id out.
+  uword tags = rawobj->ptr()->tags_;
+  if (SerializedHeaderTag::decode(tags) == kObjectId) {
+    intptr_t id = SerializedHeaderData::decode(tags);
+    WriteIndexedObject(id);
+    return true;
+  }
+
+  return false;
+}
+
+
 void SnapshotWriter::WriteInlinedObject(RawObject* raw) {
   NoGCScope no_gc;
   uword tags = raw->ptr()->tags_;
-
-  // Check if object has already been serialized, in that
-  // case just write the object id out.
-  if (SerializedHeaderTag::decode(tags) == kObjectId) {
-    intptr_t id = SerializedHeaderData::decode(tags);
-    WriteIndexedObject(id);
-    return;
-  }
-
   RawClass* cls = class_table_->At(RawObject::ClassIdTag::decode(tags));
 
   // 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);
+  intptr_t object_id = MarkObject(raw);
 
   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);
 
@@ skipping 66 matching lines @@
 
 
 void SnapshotWriterVisitor::VisitPointers(RawObject** first, RawObject** last) {
   for (RawObject** current = first; current <= last; current++) {
     RawObject* raw_obj = *current;
     writer_->WriteObject(raw_obj);
   }
 }
 
 }  // namespace dart