Rename references to "external pages" as "snapshot pages" to avoid confusion with the kind of exter…

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 661 matching lines @@
 RawObject* SnapshotReader::NewInteger(int64_t value) {
   ASSERT((value & kSmiTagMask) == kSmiTag);
   value = value >> kSmiTagShift;
   if (Smi::IsValid(value)) {
     return Smi::New(static_cast<intptr_t>(value));
   }
   return Mint::NewCanonical(value);
 }
 
 
-int32_t InstructionsWriter::GetOffsetFor(RawInstructions* instructions,
-                                         RawCode* code) {
+int32_t ImageWriter::GetOffsetFor(RawInstructions* instructions,
+                                  RawCode* code) {
 #if defined(PRODUCT)
   // Instructions are only dedup in product mode because it obfuscates profiler
   // results.
   for (intptr_t i = 0; i < instructions_.length(); i++) {
     if (instructions_[i].raw_insns_ == instructions) {
       return instructions_[i].offset_;
     }
   }
 #endif
 
   intptr_t heap_size = instructions->Size();
   intptr_t offset = next_offset_;
   next_offset_ += heap_size;
   instructions_.Add(InstructionsData(instructions, code, offset));
 
   return offset;
 }
 
 
-int32_t InstructionsWriter::GetObjectOffsetFor(RawObject* raw_object) {
+int32_t ImageWriter::GetObjectOffsetFor(RawObject* raw_object) {
   intptr_t heap_size = raw_object->Size();
   intptr_t offset = next_object_offset_;
   next_object_offset_ += heap_size;
   objects_.Add(ObjectData(raw_object));
   return offset;
 }
 
 
-void InstructionsWriter::Write(WriteStream* clustered_stream, bool vm) {
+void ImageWriter::Write(WriteStream* clustered_stream, bool vm) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   NOT_IN_PRODUCT(TimelineDurationScope tds(thread, Timeline::GetIsolateStream(),
                                            "WriteInstructions"));
 
   // Handlify collected raw pointers as building the names below
   // will allocate on the Dart heap.
   for (intptr_t i = 0; i < instructions_.length(); i++) {
     InstructionsData& data = instructions_[i];
     data.insns_ = &Instructions::Handle(zone, data.raw_insns_);
     ASSERT(data.raw_code_ != NULL);
     data.code_ = &Code::Handle(zone, data.raw_code_);
   }
   for (intptr_t i = 0; i < objects_.length(); i++) {
     ObjectData& data = objects_[i];
     data.obj_ = &Object::Handle(zone, data.raw_obj_);
   }
 
   // Append the direct-mapped RO data objects after the clustered snapshot.
   WriteROData(clustered_stream);
 
   WriteText(clustered_stream, vm);
 }
 
 
-void InstructionsWriter::WriteROData(WriteStream* stream) {
+void ImageWriter::WriteROData(WriteStream* stream) {
   stream->Align(OS::kMaxPreferredCodeAlignment);
 
   // Heap page starts here.
 
   stream->WriteWord(next_object_offset_);  // Data length.
   COMPILE_ASSERT(OS::kMaxPreferredCodeAlignment >= kObjectAlignment);
   stream->Align(OS::kMaxPreferredCodeAlignment);
 
   // Heap page objects start here.
 
@@ skipping 22 matching lines @@
   for (char c = *label; c != '\0'; c = *++label) {
     if (((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) ||
         ((c >= '0') && (c <= '9'))) {
       continue;
     }
     *label = '_';
   }
 }
 
 
-void AssemblyInstructionsWriter::WriteText(WriteStream* clustered_stream,
-                                           bool vm) {
+void AssemblyImageWriter::WriteText(WriteStream* clustered_stream, bool vm) {
   Zone* zone = Thread::Current()->zone();
 
   const char* instructions_symbol =
       vm ? "_kDartVmSnapshotInstructions" : "_kDartIsolateSnapshotInstructions";
   assembly_stream_.Print(".text\n");
   assembly_stream_.Print(".globl %s\n", instructions_symbol);
   // Start snapshot at page boundary.
   ASSERT(VirtualMemory::PageSize() >= OS::kMaxPreferredCodeAlignment);
   assembly_stream_.Print(".balign %" Pd ", 0\n", VirtualMemory::PageSize());
   assembly_stream_.Print("%s:\n", instructions_symbol);
 
   // This head also provides the gap to make the instructions snapshot
   // look like a HeapPage.
   intptr_t instructions_length = next_offset_;
   WriteWordLiteralText(instructions_length);
-  intptr_t header_words = InstructionsSnapshot::kHeaderSize / sizeof(uword);
+  intptr_t header_words = Image::kHeaderSize / sizeof(uword);
   for (intptr_t i = 1; i < header_words; i++) {
     WriteWordLiteralText(0);
   }
 
   Object& owner = Object::Handle(zone);
   String& str = String::Handle(zone);
 
   for (intptr_t i = 0; i < instructions_.length(); i++) {
     const Instructions& insns = *instructions_[i].insns_;
     const Code& code = *instructions_[i].code_;
@@ skipping 80 matching lines @@
                          OS::kMaxPreferredCodeAlignment);
   assembly_stream_.Print("%s:\n", data_symbol);
   uint8_t* buffer = clustered_stream->buffer();
   intptr_t length = clustered_stream->bytes_written();
   for (intptr_t i = 0; i < length; i++) {
     assembly_stream_.Print(".byte %" Pd "\n", buffer[i]);
   }
 }
 
 
-void BlobInstructionsWriter::WriteText(WriteStream* clustered_stream, bool vm) {
+void BlobImageWriter::WriteText(WriteStream* clustered_stream, bool vm) {
   // This header provides the gap to make the instructions snapshot look like a
   // HeapPage.
   intptr_t instructions_length = next_offset_;
   instructions_blob_stream_.WriteWord(instructions_length);
-  intptr_t header_words = InstructionsSnapshot::kHeaderSize / sizeof(uword);
+  intptr_t header_words = Image::kHeaderSize / sizeof(uword);
   for (intptr_t i = 1; i < header_words; i++) {
     instructions_blob_stream_.WriteWord(0);
   }
 
   for (intptr_t i = 0; i < instructions_.length(); i++) {
     const Instructions& insns = *instructions_[i].insns_;
 
     // 1. Write from the header to the entry point.
     {
       NoSafepointScope no_safepoint;
@@ skipping 1024 matching lines @@
       *buffer_len_ = BytesWritten();
     }
   } else {
     FreeBuffer();
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart