Toward precompiled snapshots.

runtime/vm/snapshot.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 159 matching lines @@
 
 SnapshotReader::SnapshotReader(
     const uint8_t* buffer,
     intptr_t size,
     Snapshot::Kind kind,
     ZoneGrowableArray<BackRefNode>* backward_refs,
     Isolate* isolate,
     Zone* zone)
     : BaseReader(buffer, size),
       kind_(kind),
+      snapshot_code_(false),
       isolate_(isolate),
       zone_(zone),
       heap_(isolate->heap()),
       old_space_(isolate->heap()->old_space()),
       cls_(Class::Handle(isolate)),
       obj_(Object::Handle(isolate)),
       pobj_(PassiveObject::Handle(isolate)),
       array_(Array::Handle(isolate)),
       field_(Field::Handle(isolate)),
       str_(String::Handle(isolate)),
@@ skipping 728 matching lines @@
 RawRedirectionData* SnapshotReader::NewRedirectionData() {
   ALLOC_NEW_OBJECT(RedirectionData);
 }
 
 
 RawFunction* SnapshotReader::NewFunction() {
   ALLOC_NEW_OBJECT(Function);
 }
 
 
+RawCode* SnapshotReader::NewCode(intptr_t pointer_offsets_length) {
+  ASSERT(pointer_offsets_length == 0);
+  ALLOC_NEW_OBJECT(Code);
+}
+
+
+RawObjectPool* SnapshotReader::NewObjectPool(intptr_t length) {
+  ALLOC_NEW_OBJECT(ObjectPool);
+}
+
+
+RawICData* SnapshotReader::NewICData() {
+  ALLOC_NEW_OBJECT(ICData);
+}
+
+
+RawMegamorphicCache* SnapshotReader::NewMegamorphicCache() {
+  ALLOC_NEW_OBJECT(MegamorphicCache);
+}
+
+
+RawSubtypeTestCache* SnapshotReader::NewSubtypeTestCache() {
+  ALLOC_NEW_OBJECT(SubtypeTestCache);
+}
+
+
 RawField* SnapshotReader::NewField() {
   ALLOC_NEW_OBJECT(Field);
 }
 
 
 RawLibrary* SnapshotReader::NewLibrary() {
   ALLOC_NEW_OBJECT(Library);
 }
 
 
@@ skipping 87 matching lines @@
   }
   return Mint::NewCanonical(value);
 }
 
 
 RawStacktrace* SnapshotReader::NewStacktrace() {
   ALLOC_NEW_OBJECT(Stacktrace);
 }
 
 
+RawInstructions* SnapshotReader::GetInstructionsById(int32_t id) {
+  // TODO(rmacnak): Read from shared library.
+  return Instructions::null();
+}
+
+
 intptr_t SnapshotReader::LookupInternalClass(intptr_t class_header) {
   // If the header is an object Id, lookup singleton VM classes or classes
   // stored in the object store.
   if (IsVMIsolateObject(class_header)) {
     intptr_t class_id = GetVMIsolateObjectId(class_header);
     ASSERT(IsSingletonClassId(class_id));
     return class_id;
   }
   ASSERT(SerializedHeaderTag::decode(class_header) == kObjectId);
   intptr_t class_id = SerializedHeaderData::decode(class_header);
@@ skipping 37 matching lines @@
 
 RawObject* SnapshotReader::ReadVMIsolateObject(intptr_t header_value) {
   intptr_t object_id = GetVMIsolateObjectId(header_value);
   if (object_id == kNullObject) {
     // This is a singleton null object, return it.
     return Object::null();
   }
   if (object_id == kSentinelObject) {
     return Object::sentinel().raw();
   }
+  if (object_id == kTransitionSentinelObject) {
+    return Object::transition_sentinel().raw();
+  }
   if (object_id == kEmptyArrayObject) {
     return Object::empty_array().raw();
   }
   if (object_id == kZeroArrayObject) {
     return Object::zero_array().raw();
   }
   if (object_id == kDynamicType) {
     return Object::dynamic_type();
   }
   if (object_id == kVoidType) {
@@ skipping 244 matching lines @@
 MessageSnapshotReader::~MessageSnapshotReader() {
   ResetBackwardReferenceTable();
 }
 
 
 SnapshotWriter::SnapshotWriter(Snapshot::Kind kind,
                                uint8_t** buffer,
                                ReAlloc alloc,
                                intptr_t initial_size,
                                ForwardList* forward_list,
-                               bool can_send_any_object)
+                               bool can_send_any_object,
+                               bool snapshot_code)
     : BaseWriter(buffer, alloc, initial_size),
       kind_(kind),
       isolate_(Isolate::Current()),
       object_store_(isolate_->object_store()),
       class_table_(isolate_->class_table()),
       forward_list_(forward_list),
       exception_type_(Exceptions::kNone),
       exception_msg_(NULL),
       unmarked_objects_(false),
-      can_send_any_object_(can_send_any_object) {
+      can_send_any_object_(can_send_any_object),
+      snapshot_code_(snapshot_code) {
   ASSERT(forward_list_ != NULL);
 }
 
 
 void SnapshotWriter::WriteObject(RawObject* rawobj) {
   WriteObjectImpl(rawobj, kAsInlinedObject);
   WriteForwardedObjects();
 }
 
 #define VM_OBJECT_CLASS_LIST(V)                                                \
@@ skipping 16 matching lines @@
     WriteVMIsolateObject(kNullObject);
     return;
   }
 
   // Check if it is a singleton sentinel object.
   if (rawobj == Object::sentinel().raw()) {
     WriteVMIsolateObject(kSentinelObject);
     return;
   }
 
+  // Check if it is a singleton sentinel object.
+  if (rawobj == Object::transition_sentinel().raw()) {
+    WriteVMIsolateObject(kTransitionSentinelObject);
+    return;
+  }
+
   // Check if it is a singleton empty array object.
   if (rawobj == Object::empty_array().raw()) {
     WriteVMIsolateObject(kEmptyArrayObject);
     return;
   }
 
   // Check if it is a singleton zero array object.
   if (rawobj == Object::zero_array().raw()) {
     WriteVMIsolateObject(kZeroArrayObject);
     return;
@@ skipping 66 matching lines @@
           RawTypedData* raw_obj = reinterpret_cast<RawTypedData*>(rawobj);
           raw_obj->WriteTo(this, object_id, kind());
           return;
         }
         default:
           OS::Print("class id = %" Pd "\n", id);
           break;
       }
     }
   }
-  UNREACHABLE();
+
+  const Object& obj = Object::Handle(rawobj);
+  FATAL1("Unexpected reference to object in VM isolate: %s\n", obj.ToCString());
 }
 
 #undef VM_OBJECT_WRITE
 
 
 // An object visitor which will iterate over all the script objects in the heap
 // and either count them or collect them into an array. This is used during
 // full snapshot generation of the VM isolate to write out all script
 // objects and their accompanying token streams.
 class ScriptVisitor : public ObjectVisitor {
@@ skipping 24 matching lines @@
 
  private:
   Object& objHandle_;
   intptr_t count_;
   const Array* scripts_;
 };
 
 
 FullSnapshotWriter::FullSnapshotWriter(uint8_t** vm_isolate_snapshot_buffer,
                                        uint8_t** isolate_snapshot_buffer,
-                                       ReAlloc alloc)
+                                       ReAlloc alloc,
+                                       bool snapshot_code)
     : isolate_(Isolate::Current()),
       vm_isolate_snapshot_buffer_(vm_isolate_snapshot_buffer),
       isolate_snapshot_buffer_(isolate_snapshot_buffer),
       alloc_(alloc),
       vm_isolate_snapshot_size_(0),
       isolate_snapshot_size_(0),
       forward_list_(NULL),
       scripts_(Array::Handle(isolate_)),
-      symbol_table_(Array::Handle(isolate_)) {
+      symbol_table_(Array::Handle(isolate_)),
+      snapshot_code_(snapshot_code) {
   ASSERT(isolate_snapshot_buffer_ != NULL);
   ASSERT(alloc_ != NULL);
   ASSERT(isolate_ != NULL);
   ASSERT(ClassFinalizer::AllClassesFinalized());
   ObjectStore* object_store = isolate_->object_store();
   ASSERT(object_store != NULL);
   Heap* heap = isolate_->heap();
   ASSERT(heap != NULL);
   // Ensure the class table is valid.
 #if defined(DEBUG)
@@ skipping 30 matching lines @@
 }
 
 
 void FullSnapshotWriter::WriteVmIsolateSnapshot() {
   ASSERT(vm_isolate_snapshot_buffer_ != NULL);
   SnapshotWriter writer(Snapshot::kFull,
                         vm_isolate_snapshot_buffer_,
                         alloc_,
                         kInitialSize,
                         forward_list_,
-                        true);  // Can send any kind of object.
+                        true, /* can_send_any_object */
+                        snapshot_code_);
   // Write full snapshot for the VM isolate.
   // Setup for long jump in case there is an exception while writing
   // the snapshot.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Reserve space in the output buffer for a snapshot header.
     writer.ReserveHeader();
 
     // Write out the version string.
     writer.WriteVersion();
@@ skipping 23 matching lines @@
   }
 }
 
 
 void FullSnapshotWriter::WriteIsolateFullSnapshot() {
   SnapshotWriter writer(Snapshot::kFull,
                         isolate_snapshot_buffer_,
                         alloc_,
                         kInitialSize,
                         forward_list_,
-                        true);
+                        true, /* can_send_any_object */
+                        snapshot_code_);
   ObjectStore* object_store = isolate_->object_store();
   ASSERT(object_store != NULL);
 
   // Write full snapshot for a regular isolate.
   // Setup for long jump in case there is an exception while writing
   // the snapshot.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Reserve space in the output buffer for a snapshot header.
     writer.ReserveHeader();
@@ skipping 22 matching lines @@
 
 
 void FullSnapshotWriter::WriteFullSnapshot() {
   if (vm_isolate_snapshot_buffer() != NULL) {
     WriteVmIsolateSnapshot();
   }
   WriteIsolateFullSnapshot();
 }
 
 
+PrecompiledSnapshotWriter::PrecompiledSnapshotWriter(
+    uint8_t** vm_isolate_snapshot_buffer,
+    uint8_t** isolate_snapshot_buffer,
+    ReAlloc alloc)
+  : FullSnapshotWriter(vm_isolate_snapshot_buffer,
+                       isolate_snapshot_buffer,
+                       alloc,
+                       true /* snapshot_code */) {
+}
+
+
+PrecompiledSnapshotWriter::~PrecompiledSnapshotWriter() {}
+
+
 uword SnapshotWriter::GetObjectTags(RawObject* raw) {
   uword tags = raw->ptr()->tags_;
   if (SerializedHeaderTag::decode(tags) == kObjectId) {
     intptr_t id = SerializedHeaderData::decode(tags);
     return forward_list_->NodeForObjectId(id)->tags();
   } else {
     return tags;
   }
 }
 
@@ skipping 110 matching lines @@
   // Now check if it is an object from the VM isolate (NOTE: premarked objects
   // are considered to be objects in the VM isolate). These objects are shared
   // by all isolates.
   if (rawobj->IsVMHeapObject()) {
     HandleVMIsolateObject(rawobj);
     return true;
   }
 
   // Check if it is a code object in that case just write a Null object
   // as we do not want code objects in the snapshot.
-  if (cid == kCodeCid) {
+  if (!snapshot_code() && cid == kCodeCid) {

[siva, 2015/08/19 19:40:03]

maybe
if ((cid == kCodeCid) && !snapshot_code()) {
}

as snapshot_code() will be false mostly 

[rmacnak, 2015/08/19 22:33:54]

Done.

     WriteVMIsolateObject(kNullObject);
     return true;
   }
 
   // Check if classes are not being serialized and it is preinitialized type
   // or a predefined internal VM class in the object store.
   if (kind_ != Snapshot::kFull) {
     // Check if it is an internal VM class which is in the object store.
     if (cid == kClassCid) {
       RawClass* raw_class = reinterpret_cast<RawClass*>(rawobj);
@@ skipping 489 matching lines @@
 }
 
 
 intptr_t SnapshotWriter::FirstObjectId() {
   intptr_t max_vm_isolate_object_id =
       Object::vm_isolate_snapshot_object_table().Length();
   return kMaxPredefinedObjectIds + max_vm_isolate_object_id;
 }
 
 
+int32_t GetInstructionsId(RawInstructions* instructions) {

[Florian Schneider, 2015/08/18 11:54:14]

Where is this function used?

There is already SnapshotWriter::GetInstructionsId.

[rmacnak, 2015/08/19 22:33:54]

Refactoring leftover - deleted.

+  // TODO(rmacnak): Keep list and write them to another buffer.
+  return 0;
+}
+
+
 ScriptSnapshotWriter::ScriptSnapshotWriter(uint8_t** buffer,
                                            ReAlloc alloc)
     : SnapshotWriter(Snapshot::kScript,
                      buffer,
                      alloc,
                      kInitialSize,
                      &forward_list_,
-                     true),
+                     true, /* can_send_any_object */
+                     false /* snapshot_code */),
       forward_list_(kMaxPredefinedObjectIds) {
   ASSERT(buffer != NULL);
   ASSERT(alloc != NULL);
 }
 
 
 void ScriptSnapshotWriter::WriteScriptSnapshot(const Library& lib) {
   ASSERT(kind() == Snapshot::kScript);
   ASSERT(isolate() != NULL);
   ASSERT(ClassFinalizer::AllClassesFinalized());
@@ skipping 33 matching lines @@
 
 
 MessageWriter::MessageWriter(uint8_t** buffer,
                              ReAlloc alloc,
                              bool can_send_any_object)
     : SnapshotWriter(Snapshot::kMessage,
                      buffer,
                      alloc,
                      kInitialSize,
                      &forward_list_,
-                     can_send_any_object),
+                     can_send_any_object,
+                     false /* snapshot_code */),
       forward_list_(kMaxPredefinedObjectIds) {
   ASSERT(buffer != NULL);
   ASSERT(alloc != NULL);
 }
 
 
 void MessageWriter::WriteMessage(const Object& obj) {
   ASSERT(kind() == Snapshot::kMessage);
   ASSERT(isolate() != NULL);
 
   // Setup for long jump in case there is an exception while writing
   // the message.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart