Last snapshot bits to get working precompiled hello_world on x64.

runtime/vm/pages.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/pages.h"
 
 #include "platform/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
 #include "vm/gc_sweeper.h"
@@ skipping 194 matching lines @@
 
   MutexLocker ml(pages_lock_);
   if (!is_exec) {
     if (pages_ == NULL) {
       pages_ = page;
     } else {
       pages_tail_->set_next(page);
     }
     pages_tail_ = page;
   } else {
+    // Should not allocate executable pages when running from a precompiled
+    // snapshot.
+    ASSERT(!Dart::IsRunningPrecompiledCode());
+
     if (exec_pages_ == NULL) {
       exec_pages_ = page;
     } else {
       if (FLAG_write_protect_code) {
         exec_pages_tail_->WriteProtect(false);
       }
       exec_pages_tail_->set_next(page);
       if (FLAG_write_protect_code) {
         exec_pages_tail_->WriteProtect(true);
       }
@@ skipping 790 matching lines @@
   RawObject** begin = reinterpret_cast<RawObject**>(result);
   RawObject** end = reinterpret_cast<RawObject**>(result + size);
   for (RawObject** current = begin; current < end; ++current) {
     ASSERT(!(*current)->IsHeapObject());
   }
 #endif
   return result;
 }
 
 
+void PageSpace::SetupInstructionsSnapshotPage(void* pointer, uword size) {
+  // Setup a HeapPage so precompiled Instructions can be traversed.
+  // Instructions are contiguous at [pointer, pointer + size). HeapPage
+  // expects to find objects at [memory->start() + ObjectStartOffset,
+  // memory->end()).
+  uword offset = HeapPage::ObjectStartOffset();
+  pointer = reinterpret_cast<void*>(reinterpret_cast<uword>(pointer) - offset);
+  size += offset;
+
+  ASSERT(Utils::IsAligned(pointer, OS::PreferredCodeAlignment()));
+
+  VirtualMemory* memory = VirtualMemory::ForInstructionsSnapshot(pointer, size);
+  ASSERT(memory != NULL);
+  HeapPage* page = reinterpret_cast<HeapPage*>(malloc(sizeof(HeapPage)));
+  page->memory_ = memory;
+  page->next_ = NULL;
+  page->object_end_ = memory->end();
+  page->executable_ = true;
+
+#if defined(DEBUG)
+  OS::Print("Precompiled instructions page at [0x%" Px ", 0x%" Px ")\n",
+            page->object_start(), page->object_end());
+#endif
+
+  MutexLocker ml(pages_lock_);
+  if (exec_pages_ == NULL) {
+    exec_pages_ = page;
+  } else {
+    exec_pages_tail_->set_next(page);
+  }
+  exec_pages_tail_ = page;
+}
+
+
 PageSpaceController::PageSpaceController(Heap* heap,
                                          int heap_growth_ratio,
                                          int heap_growth_max,
                                          int garbage_collection_time_ratio)
     : heap_(heap),
       is_enabled_(false),
       grow_heap_(heap_growth_max / 2),
       heap_growth_ratio_(heap_growth_ratio),
       desired_utilization_((100.0 - heap_growth_ratio) / 100.0),
       heap_growth_max_(heap_growth_max),
@@ skipping 112 matching lines @@
     return 0;
   } else {
     ASSERT(total_time >= gc_time);
     int result = static_cast<int>((static_cast<double>(gc_time) /
                                    static_cast<double>(total_time)) * 100);
     return result;
   }
 }
 
 }  // namespace dart