Last snapshot bits to get working precompiled hello_world on x64.

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 180 matching lines @@
       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_)),
+      function_(Function::Handle(zone_)),
+      megamorphic_cache_(MegamorphicCache::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),
       instructions_reader_(NULL) {
   if (instructions_buffer != NULL) {
     instructions_reader_ = new InstructionsReader(instructions_buffer);
   }
 }
@@ skipping 446 matching lines @@
   // size for the full snapshot being read.
   {
     NoSafepointScope no_safepoint;
     HeapLocker hl(isolate, old_space());
 
     // 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) = ReadObjectImpl(kAsInlinedObject);
     }
+    if (snapshot_code_) {
+      isolate->megamorphic_cache_table()->ReadFrom(this);
+    }
     for (intptr_t i = 0; i < backward_references_->length(); i++) {
       if (!(*backward_references_)[i].is_deserialized()) {
         ReadObjectImpl(kAsInlinedObject);
         (*backward_references_)[i].set_state(kIsDeserialized);
       }
     }
 
     // Validate the class table.
 #if defined(DEBUG)
     isolate->ValidateClassTable();
@@ skipping 487 matching lines @@
   // will allocate on the Dart heap.
   for (intptr_t i = 0; i < instructions_.length(); i++) {
     InstructionsData& data = instructions_[i];
     data.insns_ = &Instructions::Handle(Z, data.raw_insns_);
     ASSERT(data.raw_code_ != NULL);
     data.code_ = &Code::Handle(Z, data.raw_code_);
   }
 
   stream_.Print(".text\n");
   stream_.Print(".globl _kInstructionsSnapshot\n");
-  stream_.Print(".balign %" Pd ", 0\n", OS::PreferredCodeAlignment());
+  stream_.Print(".balign %" Pd ", 0\n", OS::kMaxPreferredCodeAlignment);
   stream_.Print("_kInstructionsSnapshot:\n");
 
+  // This head also provides the gap to make the instructions snapshot
+  // look like a HeapPage.
+  intptr_t instructions_length = next_offset_;
+  stream_.Print(".quad 0x%0.16" Px64 "\n", instructions_length);
+  intptr_t header_quads = HeaderSize() / sizeof(uint64_t);
+  for (intptr_t i = 1; i < header_quads; i++) {
+    stream_.Print(".quad 0\n");
+  }
+
   Object& owner = Object::Handle(Z);
   String& str = String::Handle(Z);
 
   for (intptr_t i = 0; i < instructions_.length(); i++) {
     const Instructions& insns = *instructions_[i].insns_;
     const Code& code = *instructions_[i].code_;
 
     ASSERT(insns.raw()->Size() % sizeof(uint64_t) == 0);
 
     {
       // 1. Write from the header to the entry point.
       NoSafepointScope no_safepoint;
+
+      bool was_marked = insns.raw()->IsMarked();
+      bool was_vmheap = insns.raw()->IsVMHeapObject();
+
+      if (!was_marked) {
+        insns.raw()->SetMarkBit();
+      }
+      if (!was_vmheap) {
+        insns.raw()->SetVMHeapObject();
+      }
+
+      // Write Instructions with the mark and VM heap bits set.
+      ASSERT(insns.raw()->IsMarked());
+      ASSERT(insns.raw()->IsVMHeapObject());
+
       uword beginning = reinterpret_cast<uword>(insns.raw()) - kHeapObjectTag;
       uword entry = beginning + Instructions::HeaderSize();
 
       ASSERT(Utils::IsAligned(beginning, sizeof(uint64_t)));
       ASSERT(Utils::IsAligned(entry, sizeof(uint64_t)));
 
       for (uint64_t* cursor = reinterpret_cast<uint64_t*>(beginning);
            cursor < reinterpret_cast<uint64_t*>(entry);
            cursor++) {
         stream_.Print(".quad 0x%0.16" Px64 "\n", *cursor);
       }
+
+      if (!was_vmheap) {
+        insns.raw()->ClearVMHeapObject();
+      }
+      if (!was_marked) {
+        insns.raw()->ClearMarkBit();
+      }

[siva, 2015/09/14 21:29:34]

This style of setting and unsetting the mark bit and VM heap object bit makes me
a bit nervous, can we instead pull the first quad word being written out outside
the loop and do the bit setting on that quad word.

[rmacnak, 2015/09/15 20:07:45]

Done.

     }
 
     // 2. Write a label at the entry point.
     owner = code.owner();
     if (owner.IsNull()) {
       const char* name = StubCode::NameOfStub(insns.EntryPoint());
       stream_.Print("Precompiled_Stub_%s:\n", name);
     } else if (owner.IsClass()) {
       str = Class::Cast(owner).Name();
       const char* name = str.ToCString();
@@ skipping 36 matching lines @@
       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();
+  ASSERT(result->IsMarked());
+
+  return result;
 }
 
 
 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;
@@ skipping 720 matching lines @@
     // Write out the version string.
     writer.WriteVersion();
 
     // Write out the full snapshot.
 
     // 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(&writer, false);
     object_store->VisitObjectPointers(&visitor);
 
+    if (snapshot_code_) {
+      isolate_->megamorphic_cache_table()->WriteTo(&writer);
+    }
+
     // Write out all forwarded objects.
     writer.WriteForwardedObjects();
 
     writer.FillHeader(writer.kind());
     writer.UnmarkAll();
 
     isolate_snapshot_size_ = writer.BytesWritten();
   } else {
     writer.ThrowException(writer.exception_type(), writer.exception_msg());
   }
@@ skipping 775 matching lines @@
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart