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 1124 matching lines @@
   return Mint::NewCanonical(value);
 }
 
 
 RawStacktrace* SnapshotReader::NewStacktrace() {
   ALLOC_NEW_OBJECT(Stacktrace);
 }
 
 
 int32_t InstructionsWriter::GetOffsetFor(RawInstructions* instructions) {
+  // Can't use instructions->Size() because the header was mutated by the
+  // snapshot writer.
+  intptr_t heap_size =
+      Instructions::InstanceSize(instructions->ptr()->size_);
   intptr_t offset = next_offset_;
-  next_offset_ += instructions->Size();
+  next_offset_ += heap_size;
   instructions_.Add(InstructionsData(instructions));
   return offset;
 }
 
 
 static void EnsureIdentifier(char* label) {
   for (char c = *label; c != '\0'; c = *++label) {
     if (((c >= 'a') && (c <= 'z')) ||
         ((c >= 'A') && (c <= 'Z')) ||
         ((c >= '0') && (c <= '9'))) {
@@ skipping 11 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_;
+  WriteWordLiteral(instructions_length);
+  intptr_t header_words = InstructionsSnapshot::kHeaderSize / sizeof(uword);
+  for (intptr_t i = 1; i < header_words; i++) {
+    WriteWordLiteral(0);
+  }
+
   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;
-      uword beginning = reinterpret_cast<uword>(insns.raw()) - kHeapObjectTag;
+
+      uword beginning = reinterpret_cast<uword>(insns.raw_ptr());
       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);
+      // Write Instructions with the mark and VM heap bits set.
+      uword marked_tags = insns.raw_ptr()->tags_;
+      marked_tags = RawObject::VMHeapObjectTag::update(true, marked_tags);
+      marked_tags = RawObject::MarkBit::update(true, marked_tags);
+
+      WriteWordLiteral(marked_tags);
+      beginning += sizeof(uword);
+
+      for (uword* cursor = reinterpret_cast<uword*>(beginning);
+           cursor < reinterpret_cast<uword*>(entry);
            cursor++) {
-        stream_.Print(".quad 0x%0.16" Px64 "\n", *cursor);
+        WriteWordLiteral(*cursor);
       }
     }
 
     // 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();
@@ skipping 12 matching lines @@
       // 3. Write from the entry point to the end.
       NoSafepointScope no_safepoint;
       uword beginning = reinterpret_cast<uword>(insns.raw()) - kHeapObjectTag;
       uword entry = beginning + Instructions::HeaderSize();
       uword end = beginning + insns.raw()->Size();
 
       ASSERT(Utils::IsAligned(beginning, sizeof(uint64_t)));
       ASSERT(Utils::IsAligned(entry, sizeof(uint64_t)));
       ASSERT(Utils::IsAligned(end, sizeof(uint64_t)));
 
-      for (uint64_t* cursor = reinterpret_cast<uint64_t*>(entry);
-           cursor < reinterpret_cast<uint64_t*>(end);
+      for (uword* cursor = reinterpret_cast<uword*>(entry);
+           cursor < reinterpret_cast<uword*>(end);
            cursor++) {
-        stream_.Print(".quad 0x%0.16" Px64 "\n", *cursor);
+        WriteWordLiteral(*cursor);
       }
     }
   }
 }
 
 
 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();
+  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 215 matching lines @@
 
 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_);
+  Dart::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 1274 matching lines @@
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart