VM: Precompiled rodata snapshot.

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 41 matching lines @@
   bool is_executable = (type == kExecutable);
   // Create the new page executable (RWX) only if we're not in W^X mode
   bool create_executable = !FLAG_write_protect_code && is_executable;
   if (!memory->Commit(create_executable)) {
     return NULL;
   }
   HeapPage* result = reinterpret_cast<HeapPage*>(memory->address());
   ASSERT(result != NULL);
   result->memory_ = memory;
   result->next_ = NULL;
-  result->executable_ = is_executable;
+  result->type_ = type;
   return result;
 }
 
 
 HeapPage* HeapPage::Allocate(intptr_t size_in_words, PageType type) {
   VirtualMemory* memory =
       VerifiedMemory::Reserve(size_in_words << kWordSizeLog2);
   if (memory == NULL) {
     return NULL;
   }
@@ skipping 52 matching lines @@
     }
     ASSERT(obj_addr == end_addr);
   }
   return Object::null();
 }
 
 
 void HeapPage::WriteProtect(bool read_only) {
   VirtualMemory::Protection prot;
   if (read_only) {
-    if (executable_) {
+    if (type_ == kExecutable) {
       prot = VirtualMemory::kReadExecute;
     } else {
       prot = VirtualMemory::kReadOnly;
     }
   } else {
     prot = VirtualMemory::kReadWrite;
   }
   bool status = memory_->Protect(prot);
   ASSERT(status);
 }
@@ skipping 512 matching lines @@
   return Object::null();
 }
 
 
 void PageSpace::WriteProtect(bool read_only, bool include_code_pages) {
   if (read_only) {
     // Avoid MakeIterable trying to write to the heap.
     AbandonBumpAllocation();
   }
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
-    if ((it.page()->type() != HeapPage::kExecutable) || include_code_pages) {
+    HeapPage::PageType page_type = it.page()->type();
+    if ((page_type != HeapPage::kReadOnlyData) &&
+        ((page_type != HeapPage::kExecutable) || include_code_pages)) {
       it.page()->WriteProtect(read_only);
     }
   }
 }
 
 
 void PageSpace::PrintToJSONObject(JSONObject* object) const {
   if (!FLAG_support_service) {
     return;
   }
@@ skipping 385 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) {
+void PageSpace::SetupExternalPage(void* pointer,
+                                  uword size,
+                                  bool is_executable) {
   // 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);
+  VirtualMemory* memory = VirtualMemory::ForExternalPage(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;
 
   MutexLocker ml(pages_lock_);
-  if (exec_pages_ == NULL) {
-    exec_pages_ = page;
+  HeapPage** first, **tail;
+  if (is_executable) {
+    ASSERT(Utils::IsAligned(pointer, OS::PreferredCodeAlignment()));
+    page->type_ = HeapPage::kExecutable;
+    first = &exec_pages_;
+    tail = &exec_pages_tail_;
   } else {
-    exec_pages_tail_->set_next(page);
+    page->type_ = HeapPage::kReadOnlyData;
+    first = &pages_;
+    tail = &pages_tail_;
   }
-  exec_pages_tail_ = page;
+  if (*first == NULL) {
+    *first = page;
+  } else {
+    (*tail)->set_next(page);
+  }
+  (*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),
@@ skipping 115 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