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"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/heap.h"
 #include "vm/lockers.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot_ids.h"
+#include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/verified_memory.h"
 #include "vm/version.h"
 
 // We currently only expect the Dart mutator to read snapshots.
 #define ASSERT_NO_SAFEPOINT_SCOPE()                            \
     isolate()->AssertCurrentThreadIsMutator();                 \
     ASSERT(thread()->no_safepoint_scope_depth() != 0)
 
 namespace dart {
@@ skipping 135 matching lines @@
 
 
 intptr_t BaseReader::ReadSmiValue() {
   return Smi::Value(ReadAsSmi());
 }
 
 
 SnapshotReader::SnapshotReader(
     const uint8_t* buffer,
     intptr_t size,
+    const uint8_t* instructions_buffer,
     Snapshot::Kind kind,
     ZoneGrowableArray<BackRefNode>* backward_refs,
     Thread* thread)
     : BaseReader(buffer, size),
+      instructions_buffer_(instructions_buffer),
       kind_(kind),
-      snapshot_code_(false),
+      snapshot_code_(instructions_buffer != NULL),
       thread_(thread),
       zone_(thread->zone()),
       heap_(isolate()->heap()),
       old_space_(thread_->isolate()->heap()->old_space()),
       cls_(Class::Handle(zone_)),
       obj_(Object::Handle(zone_)),
       pobj_(PassiveObject::Handle(zone_)),
       array_(Array::Handle(zone_)),
       field_(Field::Handle(zone_)),
       str_(String::Handle(zone_)),
       library_(Library::Handle(zone_)),
       type_(AbstractType::Handle(zone_)),
       type_arguments_(TypeArguments::Handle(zone_)),
       tokens_(Array::Handle(zone_)),
       stream_(TokenStream::Handle(zone_)),
       data_(ExternalTypedData::Handle(zone_)),
       typed_data_(TypedData::Handle(zone_)),
+      code_(Code::Handle(zone_)),
       error_(UnhandledException::Handle(zone_)),
       max_vm_isolate_object_id_(
           (kind == Snapshot::kFull) ?
               Object::vm_isolate_snapshot_object_table().Length() : 0),
-      backward_references_(backward_refs) {
+      backward_references_(backward_refs),
+      instructions_reader_(NULL) {
+  if (instructions_buffer != NULL) {
+    instructions_reader_ = new InstructionsReader(instructions_buffer);
+  }
 }
 
 
 RawObject* SnapshotReader::ReadObject() {
   // Setup for long jump in case there is an exception while reading.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     PassiveObject& obj =
         PassiveObject::Handle(isolate(), ReadObjectImpl(kAsInlinedObject));
     for (intptr_t i = 0; i < backward_references_->length(); i++) {
@@ skipping 283 matching lines @@
       } else {
         *result ^= Object::Allocate(cls_.id(),
                                     instance_size,
                                     HEAP_SPACE(kind_));
       }
     } else {
       cls_ ^= ReadObjectImpl(kAsInlinedObject);
       ASSERT(!cls_.IsNull());
       instance_size = cls_.instance_size();
     }
-    intptr_t next_field_offset = cls_.next_field_offset();
+    intptr_t next_field_offset = Class::IsSignatureClass(cls_.raw())
+      ? Closure::InstanceSize() : cls_.next_field_offset();
+
     intptr_t type_argument_field_offset = cls_.type_arguments_field_offset();
     ASSERT(next_field_offset > 0);
     // Instance::NextFieldOffset() returns the offset of the first field in
     // a Dart object.
     bool as_reference = RawObject::IsCanonical(tags) ? false : true;
     intptr_t offset = Instance::NextFieldOffset();
     intptr_t result_cid = result->GetClassId();
     while (offset < next_field_offset) {
       pobj_ = ReadObjectImpl(as_reference);
       result->SetFieldAtOffset(offset, pobj_);
@@ skipping 252 matching lines @@
 RawTwoByteString* SnapshotReader::NewTwoByteString(intptr_t len) {
   ALLOC_NEW_OBJECT_WITH_LEN(TwoByteString, len);
 }
 
 
 RawTypeArguments* SnapshotReader::NewTypeArguments(intptr_t len) {
   ALLOC_NEW_OBJECT_WITH_LEN(TypeArguments, len);
 }
 
 
+RawObjectPool* SnapshotReader::NewObjectPool(intptr_t len) {
+  ASSERT(kind_ == Snapshot::kFull);
+  ASSERT_NO_SAFEPOINT_SCOPE();
+  RawObjectPool* obj = reinterpret_cast<RawObjectPool*>(
+      AllocateUninitialized(kObjectPoolCid, ObjectPool::InstanceSize(len)));
+  obj->ptr()->length_ = len;
+  return obj;
+}
+
+
+RawLocalVarDescriptors* SnapshotReader::NewLocalVarDescriptors(
+    intptr_t num_entries) {
+  ASSERT(kind_ == Snapshot::kFull);
+  ASSERT_NO_SAFEPOINT_SCOPE();
+  RawLocalVarDescriptors* obj = reinterpret_cast<RawLocalVarDescriptors*>(
+      AllocateUninitialized(kLocalVarDescriptorsCid,
+                            LocalVarDescriptors::InstanceSize(num_entries)));
+  obj->ptr()->num_entries_ = num_entries;
+  return obj;
+}
+
+
+RawExceptionHandlers* SnapshotReader::NewExceptionHandlers(
+    intptr_t num_entries) {
+  ASSERT(kind_ == Snapshot::kFull);
+  ASSERT_NO_SAFEPOINT_SCOPE();
+  RawExceptionHandlers* obj = reinterpret_cast<RawExceptionHandlers*>(
+      AllocateUninitialized(kExceptionHandlersCid,
+                            ExceptionHandlers::InstanceSize(num_entries)));
+  obj->ptr()->num_entries_ = num_entries;
+  return obj;
+}
+
+
+RawPcDescriptors* SnapshotReader::NewPcDescriptors(intptr_t len) {
+  ASSERT(kind_ == Snapshot::kFull);
+  ASSERT_NO_SAFEPOINT_SCOPE();
+  RawPcDescriptors* obj = reinterpret_cast<RawPcDescriptors*>(
+      AllocateUninitialized(kPcDescriptorsCid,
+                            PcDescriptors::InstanceSize(len)));
+  obj->ptr()->length_ = len;
+  return obj;
+}
+
+
+RawStackmap* SnapshotReader::NewStackmap(intptr_t len) {
+  ASSERT(kind_ == Snapshot::kFull);
+  ASSERT_NO_SAFEPOINT_SCOPE();
+  RawStackmap* obj = reinterpret_cast<RawStackmap*>(
+      AllocateUninitialized(kStackmapCid, Stackmap::InstanceSize(len)));
+  obj->ptr()->length_ = len;
+  return obj;
+}
+
+
+RawContextScope* SnapshotReader::NewContextScope(intptr_t num_variables) {
+  ASSERT(kind_ == Snapshot::kFull);
+  ASSERT_NO_SAFEPOINT_SCOPE();
+  RawContextScope* obj = reinterpret_cast<RawContextScope*>(
+      AllocateUninitialized(kContextScopeCid,
+                            ContextScope::InstanceSize(num_variables)));
+  obj->ptr()->num_variables_ = num_variables;
+  return obj;
+}
+
+
+RawCode* SnapshotReader::NewCode(intptr_t pointer_offsets_length) {
+  ASSERT(pointer_offsets_length == 0);
+  ASSERT(kind_ == Snapshot::kFull);
+  ASSERT_NO_SAFEPOINT_SCOPE();
+  RawCode* obj = reinterpret_cast<RawCode*>(
+      AllocateUninitialized(kCodeCid, Code::InstanceSize(0)));
+  return obj;
+}
+
+
 RawTokenStream* SnapshotReader::NewTokenStream(intptr_t len) {
   ASSERT(kind_ == Snapshot::kFull);
   ASSERT_NO_SAFEPOINT_SCOPE();
   stream_ = reinterpret_cast<RawTokenStream*>(
       AllocateUninitialized(kTokenStreamCid, TokenStream::InstanceSize()));
   uint8_t* array = const_cast<uint8_t*>(CurrentBufferAddress());
   ASSERT(array != NULL);
   Advance(len);
   data_ = reinterpret_cast<RawExternalTypedData*>(
       AllocateUninitialized(kExternalTypedDataUint8ArrayCid,
@@ skipping 129 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);
 }
 
 
+RawLinkedHashMap* SnapshotReader::NewLinkedHashMap() {
+  ALLOC_NEW_OBJECT(LinkedHashMap);
+}
+
+
 RawMegamorphicCache* SnapshotReader::NewMegamorphicCache() {
   ALLOC_NEW_OBJECT(MegamorphicCache);
 }
 
 
 RawSubtypeTestCache* SnapshotReader::NewSubtypeTestCache() {
   ALLOC_NEW_OBJECT(SubtypeTestCache);
 }
 
 
@@ skipping 97 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.
+int32_t InstructionsWriter::GetOffsetFor(RawInstructions* instructions) {
+  // Instructions are allocated with the code alignment and we don't write
+  // anything else in the text section.
+  ASSERT(Utils::IsAligned(stream_.bytes_written(),
+                          OS::PreferredCodeAlignment()));
+
+  intptr_t offset = stream_.bytes_written();
+  stream_.WriteBytes(reinterpret_cast<uint8_t*>(instructions) - kHeapObjectTag,
+                     instructions->Size());
+  return offset;
+}
+
+
+RawInstructions* InstructionsReader::GetInstructionsAt(int32_t offset,
+                                                       uword expected_tags) {
+  ASSERT(Utils::IsAligned(offset, OS::PreferredCodeAlignment()));
+
+  RawInstructions* result =
+      reinterpret_cast<RawInstructions*>(
+          reinterpret_cast<uword>(buffer_) + offset + kHeapObjectTag);
+
+  uword actual_tags = result->ptr()->tags_;
+  if (actual_tags != expected_tags) {
+    FATAL2("Instructions tag mismatch: expected %" Pd ", saw %" Pd,
+           expected_tags,
+           actual_tags);
+  }
+
+  // TODO(rmacnak): The above contains stale pointers to a Code and an
+  // ObjectPool. Return the actual result after calling convention change.
   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);
-  ASSERT(IsObjectStoreClassId(class_id));
+  ASSERT(IsObjectStoreClassId(class_id) || IsSingletonClassId(class_id));
   return class_id;
 }
 
 
 RawObject* SnapshotReader::AllocateUninitialized(intptr_t class_id,
                                                  intptr_t size) {
   ASSERT_NO_SAFEPOINT_SCOPE();
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
 
   // Allocate memory where all words look like smis. This is currently
@@ skipping 177 matching lines @@
       reinterpret_cast<RawObject**>(result.raw()->ptr());
   for (intptr_t i = 0; i < len; i++) {
     *PassiveObjectHandle() = ReadObjectImpl(as_reference,
                                             object_id,
                                             (i + offset));
     result.SetAt(i, *PassiveObjectHandle());
   }
 }
 
 
-VmIsolateSnapshotReader::VmIsolateSnapshotReader(const uint8_t* buffer,
-                                                 intptr_t size,
-                                                 Thread* thread)
-    : SnapshotReader(buffer,
-                     size,
-                     Snapshot::kFull,
-                     new ZoneGrowableArray<BackRefNode>(
-                         kNumVmIsolateSnapshotReferences),
-                     thread) {
+VmIsolateSnapshotReader::VmIsolateSnapshotReader(
+    const uint8_t* buffer,
+    intptr_t size,
+    const uint8_t* instructions_buffer,
+    Thread* thread)
+      : SnapshotReader(buffer,
+                       size,
+                       instructions_buffer,
+                       Snapshot::kFull,
+                       new ZoneGrowableArray<BackRefNode>(
+                           kNumVmIsolateSnapshotReferences),
+                       thread) {
 }
 
 
 VmIsolateSnapshotReader::~VmIsolateSnapshotReader() {
   intptr_t len = GetBackwardReferenceTable()->length();
   Object::InitVmIsolateSnapshotObjectTable(len);
   ZoneGrowableArray<BackRefNode>* backrefs = GetBackwardReferenceTable();
   for (intptr_t i = 0; i < len; i++) {
     Object::vm_isolate_snapshot_object_table().SetAt(
         i, *(backrefs->At(i).reference()));
   }
   ResetBackwardReferenceTable();
+  Object::set_instructions_snapshot_buffer(instructions_buffer_);
 }
 
 
 RawApiError* VmIsolateSnapshotReader::ReadVmIsolateSnapshot() {
   ASSERT(kind() == Snapshot::kFull);
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ASSERT(isolate == Dart::vm_isolate());
   ObjectStore* object_store = isolate->object_store();
   ASSERT(object_store != NULL);
@@ skipping 13 matching lines @@
     // Read in the symbol table.
     object_store->symbol_table_ = reinterpret_cast<RawArray*>(ReadObject());
 
     Symbols::InitOnceFromSnapshot(isolate);
 
     // Read in all the script objects and the accompanying token streams
     // for bootstrap libraries so that they are in the VM isolate's read
     // only memory.
     *(ArrayHandle()) ^= ReadObject();
 
+
+    if (snapshot_code()) {
+      for (intptr_t i = 0;
+           i < ArgumentsDescriptor::kCachedDescriptorCount;
+           i++) {
+        *(ArrayHandle()) ^= ReadObject();
+        // TODO(rmacnak):
+        // ArgumentsDescriptor::InitOnceFromSnapshot(i, *(ArrayHandle()));
+      }
+
+      ObjectPool::CheckedHandle(ReadObject());  // empty pool
+      PcDescriptors::CheckedHandle(ReadObject());  // empty pc desc
+      LocalVarDescriptors::CheckedHandle(ReadObject());  // empty var desc
+      ExceptionHandlers::CheckedHandle(ReadObject());  // empty exc handlers
+
+#define READ_STUB(name)                                                       \
+      *(CodeHandle()) ^= ReadObject();
+      // TODO(rmacnak):
+      // StubCode::name##_entry()->InitOnceFromSnapshot(CodeHandle())
+      VM_STUB_CODE_LIST(READ_STUB);
+#undef READ_STUB
+    }
+
     // Validate the class table.
 #if defined(DEBUG)
     isolate->ValidateClassTable();
 #endif
 
     return ApiError::null();
   }
 }
 
 
 IsolateSnapshotReader::IsolateSnapshotReader(const uint8_t* buffer,
                                              intptr_t size,
+                                             const uint8_t* instructions_buffer,
                                              Thread* thread)
     : SnapshotReader(buffer,
                      size,
+                     instructions_buffer,
                      Snapshot::kFull,
                      new ZoneGrowableArray<BackRefNode>(
                          kNumInitialReferencesInFullSnapshot),
                      thread) {
 }
 
 
 IsolateSnapshotReader::~IsolateSnapshotReader() {
   ResetBackwardReferenceTable();
 }
 
 
 ScriptSnapshotReader::ScriptSnapshotReader(const uint8_t* buffer,
                                            intptr_t size,
                                            Thread* thread)
     : SnapshotReader(buffer,
                      size,
+                     NULL, /* instructions_buffer */
                      Snapshot::kScript,
                      new ZoneGrowableArray<BackRefNode>(kNumInitialReferences),
                      thread) {
 }
 
 
 ScriptSnapshotReader::~ScriptSnapshotReader() {
   ResetBackwardReferenceTable();
 }
 
 
 MessageSnapshotReader::MessageSnapshotReader(const uint8_t* buffer,
                                              intptr_t size,
                                              Thread* thread)
     : SnapshotReader(buffer,
                      size,
+                     NULL, /* instructions_buffer */
                      Snapshot::kMessage,
                      new ZoneGrowableArray<BackRefNode>(kNumInitialReferences),
                      thread) {
 }
 
 
 MessageSnapshotReader::~MessageSnapshotReader() {
   ResetBackwardReferenceTable();
 }
 
 
 SnapshotWriter::SnapshotWriter(Snapshot::Kind kind,
                                uint8_t** buffer,
                                ReAlloc alloc,
                                intptr_t initial_size,
                                ForwardList* forward_list,
+                               InstructionsWriter* instructions_writer,
                                bool can_send_any_object,
-                               bool snapshot_code)
+                               bool snapshot_code,
+                               bool vm_isolate_is_symbolic)
     : BaseWriter(buffer, alloc, initial_size),
       kind_(kind),
       thread_(Thread::Current()),
       object_store_(thread_->isolate()->object_store()),
       class_table_(thread_->isolate()->class_table()),
       forward_list_(forward_list),
+      instructions_writer_(instructions_writer),
       exception_type_(Exceptions::kNone),
       exception_msg_(NULL),
       unmarked_objects_(false),
       can_send_any_object_(can_send_any_object),
-      snapshot_code_(snapshot_code) {
+      snapshot_code_(snapshot_code),
+      vm_isolate_is_symbolic_(vm_isolate_is_symbolic) {
   ASSERT(forward_list_ != NULL);
 }
 
 
 void SnapshotWriter::WriteObject(RawObject* rawobj) {
   WriteObjectImpl(rawobj, kAsInlinedObject);
   WriteForwardedObjects();
 }
 
 #define VM_OBJECT_CLASS_LIST(V)                                                \
   V(OneByteString)                                                             \
   V(Mint)                                                                      \
   V(Bigint)                                                                    \
   V(Double)                                                                    \
   V(ImmutableArray)                                                            \
 
 #define VM_OBJECT_WRITE(clazz)                                                 \
   case clazz::kClassId: {                                                      \
     object_id = forward_list_->AddObject(rawobj, kIsSerialized);               \
     Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(rawobj);               \
     raw_obj->WriteTo(this, object_id, kind());                                 \
-    return;                                                                    \
+    return true;                                                               \
   }                                                                            \
 
-void SnapshotWriter::HandleVMIsolateObject(RawObject* rawobj) {
+bool SnapshotWriter::HandleVMIsolateObject(RawObject* rawobj) {
   // Check if it is a singleton null object.
   if (rawobj == Object::null()) {
     WriteVMIsolateObject(kNullObject);
-    return;
+    return true;
   }
 
   // Check if it is a singleton sentinel object.
   if (rawobj == Object::sentinel().raw()) {
     WriteVMIsolateObject(kSentinelObject);
-    return;
+    return true;
   }
 
   // Check if it is a singleton sentinel object.
   if (rawobj == Object::transition_sentinel().raw()) {
     WriteVMIsolateObject(kTransitionSentinelObject);
-    return;
+    return true;
   }
 
   // Check if it is a singleton empty array object.
   if (rawobj == Object::empty_array().raw()) {
     WriteVMIsolateObject(kEmptyArrayObject);
-    return;
+    return true;
   }
 
   // Check if it is a singleton zero array object.
   if (rawobj == Object::zero_array().raw()) {
     WriteVMIsolateObject(kZeroArrayObject);
-    return;
+    return true;
   }
 
   // Check if it is a singleton dyanmic Type object.
   if (rawobj == Object::dynamic_type()) {
     WriteVMIsolateObject(kDynamicType);
-    return;
+    return true;
   }
 
   // Check if it is a singleton void Type object.
   if (rawobj == Object::void_type()) {
     WriteVMIsolateObject(kVoidType);
-    return;
+    return true;
   }
 
   // Check if it is a singleton boolean true object.
   if (rawobj == Bool::True().raw()) {
     WriteVMIsolateObject(kTrueValue);
-    return;
+    return true;
   }
 
   // Check if it is a singleton boolean false object.
   if (rawobj == Bool::False().raw()) {
     WriteVMIsolateObject(kFalseValue);
-    return;
+    return true;
   }
 
   // Check if it is a singleton extractor parameter types array.
   if (rawobj == Object::extractor_parameter_types().raw()) {
     WriteVMIsolateObject(kExtractorParameterTypes);
-    return;
+    return true;
   }
 
   // Check if it is a singleton extractor parameter names array.
   if (rawobj == Object::extractor_parameter_names().raw()) {
     WriteVMIsolateObject(kExtractorParameterNames);
-    return;
+    return true;
   }
 
   // Check if it is a singleton empty context scope object.
   if (rawobj == Object::empty_context_scope().raw()) {
     WriteVMIsolateObject(kEmptyContextScopeObject);
-    return;
+    return true;
   }
 
   // Check if it is a singleton class object which is shared by
   // all isolates.
   intptr_t id = rawobj->GetClassId();
   if (id == kClassCid) {
     RawClass* raw_class = reinterpret_cast<RawClass*>(rawobj);
     intptr_t class_id = raw_class->ptr()->id_;
     if (IsSingletonClassId(class_id)) {
       intptr_t object_id = ObjectIdFromClassId(class_id);
       WriteVMIsolateObject(object_id);
-      return;
+      return true;
     }
   }
 
   if (kind() == Snapshot::kFull) {
     // Check it is a predefined symbol in the VM isolate.
     id = Symbols::LookupVMSymbol(rawobj);
     if (id != kInvalidIndex) {
       WriteVMIsolateObject(id);
-      return;
+      return true;
     }
 
     // Check if it is an object from the vm isolate snapshot object table.
     id = FindVmSnapshotObject(rawobj);
     if (id != kInvalidIndex) {
       WriteIndexedObject(id);
-      return;
+      return true;
     }
   } else {
     // In the case of script snapshots or for messages we do not use
     // the index into the vm isolate snapshot object table, instead we
     // explicitly write the object out.
     intptr_t object_id = forward_list_->FindObject(rawobj);
     if (object_id != -1) {
       WriteIndexedObject(object_id);
-      return;
+      return true;
     } else {
       switch (id) {
         VM_OBJECT_CLASS_LIST(VM_OBJECT_WRITE)
         case kTypedDataUint32ArrayCid: {
           object_id = forward_list_->AddObject(rawobj, kIsSerialized);
           RawTypedData* raw_obj = reinterpret_cast<RawTypedData*>(rawobj);
           raw_obj->WriteTo(this, object_id, kind());
-          return;
+          return true;
         }
         default:
           OS::Print("class id = %" Pd "\n", id);
           break;
       }
     }
   }
 
+  if (!vm_isolate_is_symbolic()) {
+    return false;
+  }
+
   const Object& obj = Object::Handle(rawobj);
   FATAL1("Unexpected reference to object in VM isolate: %s\n", obj.ToCString());
+  return false;
 }
 
 #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,
+                                       uint8_t** instructions_snapshot_buffer,
                                        ReAlloc alloc,
-                                       bool snapshot_code)
+                                       bool snapshot_code,
+                                       bool vm_isolate_is_symbolic)
     : isolate_(Isolate::Current()),
       vm_isolate_snapshot_buffer_(vm_isolate_snapshot_buffer),
       isolate_snapshot_buffer_(isolate_snapshot_buffer),
+      instructions_snapshot_buffer_(instructions_snapshot_buffer),
       alloc_(alloc),
       vm_isolate_snapshot_size_(0),
       isolate_snapshot_size_(0),
+      instructions_snapshot_size_(0),
       forward_list_(NULL),
+      instructions_writer_(NULL),
       scripts_(Array::Handle(isolate_)),
       symbol_table_(Array::Handle(isolate_)),
-      snapshot_code_(snapshot_code) {
+      snapshot_code_(snapshot_code),
+      vm_isolate_is_symbolic_(vm_isolate_is_symbolic) {
   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 13 matching lines @@
   heap->IterateOldObjects(&script_visitor);
 
   // Stash the symbol table away for writing and reading into the vm isolate,
   // and reset the symbol table for the regular isolate so that we do not
   // write these symbols into the snapshot of a regular dart isolate.
   symbol_table_ = object_store->symbol_table();
   Symbols::SetupSymbolTable(isolate_);
 
   forward_list_ = new ForwardList(SnapshotWriter::FirstObjectId());
   ASSERT(forward_list_ != NULL);
+
+  if (instructions_snapshot_buffer != NULL) {
+    instructions_writer_ = new InstructionsWriter(instructions_snapshot_buffer,
+                                                  alloc,
+                                                  kInitialSize);
+  }
 }
 
 
 FullSnapshotWriter::~FullSnapshotWriter() {
   delete forward_list_;
   symbol_table_ = Array::null();
   scripts_ = Array::null();
 }
 
 
 void FullSnapshotWriter::WriteVmIsolateSnapshot() {
   ASSERT(vm_isolate_snapshot_buffer_ != NULL);
   SnapshotWriter writer(Snapshot::kFull,
                         vm_isolate_snapshot_buffer_,
                         alloc_,
                         kInitialSize,
                         forward_list_,
+                        instructions_writer_,
                         true, /* can_send_any_object */
-                        snapshot_code_);
+                        snapshot_code_,
+                        vm_isolate_is_symbolic_);
   // 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();
 
     /*
      * Now Write out the following
      * - the symbol table
      * - all the scripts and token streams for these scripts
      *
      **/
     // Write out the symbol table.
     writer.WriteObject(symbol_table_.raw());
 
     // Write out all the script objects and the accompanying token streams
     // for the bootstrap libraries so that they are in the VM isolate
     // read only memory.
     writer.WriteObject(scripts_.raw());
 
-    // Write out all forwarded objects.
-    writer.WriteForwardedObjects();
+    if (snapshot_code_) {
+      ASSERT(!vm_isolate_is_symbolic_);
+
+      for (intptr_t i = 0;
+           i < ArgumentsDescriptor::kCachedDescriptorCount;
+           i++) {
+        writer.WriteObject(ArgumentsDescriptor::cached_args_descriptors_[i]);
+      }
+
+      writer.WriteObject(Object::empty_object_pool().raw());
+      writer.WriteObject(Object::empty_descriptors().raw());
+      writer.WriteObject(Object::empty_var_descriptors().raw());
+      writer.WriteObject(Object::empty_exception_handlers().raw());
+
+#define WRITE_STUB(name)                                                       \
+      writer.WriteObject(StubCode::name##_entry()->code());
+      VM_STUB_CODE_LIST(WRITE_STUB);
+#undef WRITE_STUB
+    }
+
 
     writer.FillHeader(writer.kind());
 
     vm_isolate_snapshot_size_ = writer.BytesWritten();
   } else {
     writer.ThrowException(writer.exception_type(), writer.exception_msg());
   }
 }
 
 
 void FullSnapshotWriter::WriteIsolateFullSnapshot() {
   SnapshotWriter writer(Snapshot::kFull,
                         isolate_snapshot_buffer_,
                         alloc_,
                         kInitialSize,
                         forward_list_,
+                        instructions_writer_,
                         true, /* can_send_any_object */
-                        snapshot_code_);
+                        snapshot_code_,
+                        true /* vm_isolate_is_symbolic */);
   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 14 matching lines @@
     writer.FillHeader(writer.kind());
     writer.UnmarkAll();
 
     isolate_snapshot_size_ = writer.BytesWritten();
   } else {
     writer.ThrowException(writer.exception_type(), writer.exception_msg());
   }
 }
 
 
+class WritableVMIsolateScope : StackResource {
+ public:
+  explicit WritableVMIsolateScope(Thread* thread) : StackResource(thread) {
+    Dart::vm_isolate()->heap()->WriteProtect(false);
+  }
+
+  ~WritableVMIsolateScope() {
+    ASSERT(Dart::vm_isolate()->heap()->UsedInWords(Heap::kNew) == 0);
+    Dart::vm_isolate()->heap()->WriteProtect(true);
+  }
+};
+
+
 void FullSnapshotWriter::WriteFullSnapshot() {
-  if (vm_isolate_snapshot_buffer() != NULL) {
-    WriteVmIsolateSnapshot();
+  if (!vm_isolate_is_symbolic_) {
+    // TODO(asiva): Don't mutate object headers during serialization.
+    WritableVMIsolateScope scope(Thread::Current());
+
+    if (vm_isolate_snapshot_buffer() != NULL) {
+      WriteVmIsolateSnapshot();
+    }
+    WriteIsolateFullSnapshot();
+
+    instructions_snapshot_size_ = instructions_writer_->BytesWritten();
+  } else {
+    if (vm_isolate_snapshot_buffer() != NULL) {
+      WriteVmIsolateSnapshot();
+    }
+    WriteIsolateFullSnapshot();
   }
-  WriteIsolateFullSnapshot();
 }
 
 
 PrecompiledSnapshotWriter::PrecompiledSnapshotWriter(
     uint8_t** vm_isolate_snapshot_buffer,
     uint8_t** isolate_snapshot_buffer,
+    uint8_t** instructions_snapshot_buffer,
     ReAlloc alloc)
   : FullSnapshotWriter(vm_isolate_snapshot_buffer,
                        isolate_snapshot_buffer,
+                       instructions_snapshot_buffer,
                        alloc,
-                       true /* snapshot_code */) {
+                       true, /* snapshot_code */
+                       false /* vm_isolate_is_symbolic */) {
 }
 
 
 PrecompiledSnapshotWriter::~PrecompiledSnapshotWriter() {}
 
 
 uword SnapshotWriter::GetObjectTags(RawObject* raw) {
   uword tags = raw->ptr()->tags_;
   if (SerializedHeaderTag::decode(tags) == kObjectId) {
     intptr_t id = SerializedHeaderData::decode(tags);
@@ skipping 109 matching lines @@
   uword tags = rawobj->ptr()->tags_;
   if (SerializedHeaderTag::decode(tags) == kObjectId) {
     intptr_t id = SerializedHeaderData::decode(tags);
     WriteIndexedObject(id);
     return true;
   }
 
   // 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);
+  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 && !snapshot_code()) {
     WriteVMIsolateObject(kNullObject);
     return true;
   }
 
@@ skipping 171 matching lines @@
     case kTypedData##clazz##ViewCid:                                           \
 
     CLASS_LIST_TYPED_DATA(SNAPSHOT_WRITE)
     case kByteDataViewCid: {
       WriteInstance(object_id, raw, cls, tags);
       return;
     }
 #undef SNAPSHOT_WRITE
     default: break;
   }
-  UNREACHABLE();
+
+  const Object& obj = Object::Handle(raw);
+  FATAL1("Unexpected inlined object: %s\n", obj.ToCString());
 }
 
 
 class WriteInlinedObjectVisitor : public ObjectVisitor {
  public:
   explicit WriteInlinedObjectVisitor(SnapshotWriter* writer)
       : ObjectVisitor(Isolate::Current()), writer_(writer) {}
 
   virtual void VisitObject(RawObject* obj) {
     writer_->WriteInlinedObject(obj);
@@ skipping 175 matching lines @@
 }
 
 
 void SnapshotWriter::WriteInstance(intptr_t object_id,
                                    RawObject* raw,
                                    RawClass* cls,
                                    intptr_t tags) {
   // Check if the instance has native fields and throw an exception if it does.
   CheckForNativeFields(cls);
 
-  // Check if object is a closure that is serializable, if the object is a
-  // closure that is not serializable this will throw an exception.
-  RawFunction* func = IsSerializableClosure(cls, raw);
-  if (func != Function::null()) {
-    WriteStaticImplicitClosure(object_id, func, tags);
-    return;
+  if ((kind() == Snapshot::kMessage) || (kind() == Snapshot::kScript)) {
+    // Check if object is a closure that is serializable, if the object is a
+    // closure that is not serializable this will throw an exception.
+    RawFunction* func = IsSerializableClosure(cls, raw);
+    if (func != Function::null()) {
+      WriteStaticImplicitClosure(object_id, func, tags);
+      return;
+    }
   }
 
   // Object is regular dart instance.
   intptr_t next_field_offset = Class::IsSignatureClass(cls) ?
       Closure::InstanceSize() :
       cls->ptr()->next_field_offset_in_words_ << kWordSizeLog2;
   ASSERT(next_field_offset > 0);
 
   // Write out the serialization header value for this object.
   WriteInlinedObjectHeader(object_id);
@@ skipping 109 matching lines @@
 }
 
 
 ScriptSnapshotWriter::ScriptSnapshotWriter(uint8_t** buffer,
                                            ReAlloc alloc)
     : SnapshotWriter(Snapshot::kScript,
                      buffer,
                      alloc,
                      kInitialSize,
                      &forward_list_,
+                     NULL, /* instructions_writer */
                      true, /* can_send_any_object */
-                     false /* snapshot_code */),
+                     false, /* snapshot_code */
+                     true /* vm_isolate_is_symbolic */),
       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_,
+                     NULL, /* instructions_writer */
                      can_send_any_object,
-                     false /* snapshot_code */),
+                     false, /* snapshot_code */
+                     true /* vm_isolate_is_symbolic */),
       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