First step towards generation of application script snapshots

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 25 matching lines @@
           index <= ObjectStore::kListInterface);
 }
 
 
 // TODO(5411462): Temporary setup of snapshot for testing purposes,
 // the actual creation of a snapshot maybe done differently.
 const Snapshot* Snapshot::SetupFromBuffer(const void* raw_memory) {
   ASSERT(raw_memory != NULL);
   ASSERT(kHeaderSize == sizeof(Snapshot));
   ASSERT(kLengthIndex == length_offset());
-  ASSERT((kSnapshotFlagIndex * sizeof(int32_t)) == full_snapshot_offset());
+  ASSERT((kSnapshotFlagIndex * sizeof(int32_t)) == kind_offset());
   ASSERT((kHeapObjectTag & kInlined));
   ASSERT((kHeapObjectTag & kObjectId));
   ASSERT((kObjectAlignmentMask & kObjectId) == kObjectId);
   const Snapshot* snapshot = reinterpret_cast<const Snapshot*>(raw_memory);
   return snapshot;
 }
 
 
 RawObject* SnapshotReader::ReadObject() {
   intptr_t header = Read<intptr_t>();
   if ((header & kSmiTagMask) == 0) {
     return reinterpret_cast<RawObject*>(header);
   }
   return ReadObjectImpl(header);
 }
 
 
 RawClass* SnapshotReader::ReadClassId(intptr_t object_id) {
-  ASSERT(!classes_serialized_);
+  ASSERT(kind_ != Snapshot::kFull);
   // Read the class header information and lookup the class.
   intptr_t class_header = Read<intptr_t>();
   ASSERT((class_header & kSmiTagMask) != 0);
   Class& cls = Class::Handle();
   cls ^= LookupInternalClass(class_header);
   AddBackwardReference(object_id, &cls);
   if (cls.IsNull()) {
     // Read the library/class information and lookup the class.
     String& library_url = String::Handle();
     library_url ^= ReadObjectImpl(class_header);
     String& class_name = String::Handle();
     class_name ^= ReadObject();
     const Library& library =
         Library::Handle(Library::LookupLibrary(library_url));
     ASSERT(!library.IsNull());
     cls ^= library.LookupClass(class_name);
   }
   ASSERT(!cls.IsNull());
   return cls.raw();
 }
 
 
 void SnapshotReader::AddBackwardReference(intptr_t id, Object* obj) {
   ASSERT((id - kMaxPredefinedObjectIds) == backward_references_.length());
   backward_references_.Add(obj);
 }
 
 
 void SnapshotReader::ReadFullSnapshot() {
-  ASSERT(classes_serialized_);
+  ASSERT(kind_ == Snapshot::kFull);
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ObjectStore* object_store = isolate->object_store();
   ASSERT(object_store != NULL);
 
   // Read in all the objects stored in the object store.
   intptr_t num_flds = (object_store->to() - object_store->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     *(object_store->from() + i) = ReadObject();
   }
@@ skipping 41 matching lines @@
     return Object::sentinel();
   }
   if (IsSingletonClassId(object_id)) {
     return Object::GetSingletonClass(object_id);  // return singleton object.
   } else if (IsObjectStoreClassId(object_id)) {
     return object_store()->GetClass(object_id);
   } else if (object_id == ObjectStore::kTrueValue) {
     return object_store()->true_value();
   } else if (object_id == ObjectStore::kFalseValue) {
     return object_store()->false_value();
-  } else if (!classes_serialized_) {
+  } else if (kind_ != Snapshot::kFull) {
     if (IsObjectStoreTypeId(object_id)) {
       return object_store()->GetType(object_id);  // return type object.
     }
   }
 
   ASSERT(object_id >= kMaxPredefinedObjectIds);
   intptr_t index = object_id - kMaxPredefinedObjectIds;
   ASSERT(index < backward_references_.length());
   return backward_references_[index]->raw();
 }
@@ skipping 24 matching lines @@
     }
     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, classes_serialized_);            \
+      return clazz::ReadFrom(this, object_id, kind_);                          \
     }
     CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
 #undef SNAPSHOT_READ
     default: break;
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
@@ skipping 65 matching lines @@
     return;
   }
 
   // Check if it is a singleton boolean false value.
   if (rawobj == object_store()->false_value()) {
     WriteObjectHeader(kObjectId, ObjectStore::kFalseValue);
     return;
   }
 
   // Check if classes are not being serialized and it is preinitialized type.
-  if (!serialize_classes_) {
+  if (kind_ != Snapshot::kFull) {
     RawType* raw_type = reinterpret_cast<RawType*>(rawobj);
     index = object_store()->GetTypeIndex(raw_type);
     if (index != ObjectStore::kInvalidIndex) {
       WriteObjectHeader(kObjectId, index);
       return;
     }
   }
 
   // Now write the object out inline in the stream.
   WriteInlinedObject(rawobj);
@@ skipping 11 matching lines @@
 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() {
-  ASSERT(serialize_classes_);
+  ASSERT(kind_ == Snapshot::kFull);
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ObjectStore* object_store = isolate->object_store();
   ASSERT(object_store != NULL);
 
   // Write out all the objects in the object store of the isolate which
   // is the root set for all dart allocated objects at this point.
   SnapshotWriterVisitor visitor(this);
   object_store->VisitObjectPointers(&visitor);
 
@@ skipping 57 matching lines @@
       WriteObject(*reinterpret_cast<RawObject**>(
           reinterpret_cast<uword>(raw->ptr()) + offset));
       offset += kWordSize;
     }
     return;
   }
   switch (kind) {
 #define SNAPSHOT_WRITE(clazz)                                                  \
     case clazz::kInstanceKind: {                                               \
       Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(raw);                \
-      raw_obj->WriteTo(this, object_id, serialize_classes_);                   \
+      raw_obj->WriteTo(this, object_id, kind_);                                \
       return;                                                                  \
     }                                                                          \
 
     CLASS_LIST_NO_OBJECT(SNAPSHOT_WRITE)
 #undef SNAPSHOT_WRITE
     default: break;
   }
   UNREACHABLE();
 }
 
 
 void SnapshotWriter::WriteClassId(RawClass* cls) {
-  ASSERT(!serialize_classes_);
+  ASSERT(kind_ != Snapshot::kFull);
   int id = object_store()->GetClassIndex(cls);
   if (IsSingletonClassId(id) || IsObjectStoreClassId(id)) {
     WriteObjectHeader(kObjectId, 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 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