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

runtime/vm/clustered_snapshot.cc

 // Copyright (c) 2016, 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/clustered_snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 4448 matching lines @@
     }
   }
 };
 
 
 Serializer::Serializer(Thread* thread,
                        Snapshot::Kind kind,
                        uint8_t** buffer,
                        ReAlloc alloc,
                        intptr_t initial_size,
-                       InstructionsWriter* instructions_writer)
+                       ImageWriter* image_writer)
     : StackResource(thread),
       heap_(thread->isolate()->heap()),
       zone_(thread->zone()),
       kind_(kind),
       stream_(buffer, alloc, initial_size),
-      instructions_writer_(instructions_writer),
+      image_writer_(image_writer),
       clusters_by_cid_(NULL),
       stack_(),
       num_cids_(0),
       num_base_objects_(0),
       num_written_objects_(0),
       next_ref_index_(1) {
   num_cids_ = thread->isolate()->class_table()->NumCids();
   clusters_by_cid_ = new SerializationCluster*[num_cids_];
   for (intptr_t i = 0; i < num_cids_; i++) {
     clusters_by_cid_[i] = NULL;
@@ skipping 787 matching lines @@
 
   intptr_t count() const { return count_; }
 
  private:
   Object& objHandle_;
   intptr_t count_;
   const Array* token_streams_;
 };
 
 
-FullSnapshotWriter::FullSnapshotWriter(
-    Snapshot::Kind kind,
-    uint8_t** vm_snapshot_data_buffer,
-    uint8_t** isolate_snapshot_data_buffer,
-    ReAlloc alloc,
-    InstructionsWriter* vm_instructions_writer,
-    InstructionsWriter* isolate_instructions_writer)
+FullSnapshotWriter::FullSnapshotWriter(Snapshot::Kind kind,
+                                       uint8_t** vm_snapshot_data_buffer,
+                                       uint8_t** isolate_snapshot_data_buffer,
+                                       ReAlloc alloc,
+                                       ImageWriter* vm_image_writer,
+                                       ImageWriter* isolate_image_writer)
     : thread_(Thread::Current()),
       kind_(kind),
       vm_snapshot_data_buffer_(vm_snapshot_data_buffer),
       isolate_snapshot_data_buffer_(isolate_snapshot_data_buffer),
       alloc_(alloc),
       vm_isolate_snapshot_size_(0),
       isolate_snapshot_size_(0),
-      vm_instructions_writer_(vm_instructions_writer),
-      isolate_instructions_writer_(isolate_instructions_writer),
+      vm_image_writer_(vm_image_writer),
+      isolate_image_writer_(isolate_image_writer),
       token_streams_(Array::Handle(zone())),
       saved_symbol_table_(Array::Handle(zone())),
       new_vm_symbol_table_(Array::Handle(zone())),
       clustered_vm_size_(0),
       clustered_isolate_size_(0),
       mapped_data_size_(0),
       mapped_instructions_size_(0) {
   ASSERT(isolate_snapshot_data_buffer_ != NULL);
   ASSERT(alloc_ != NULL);
   ASSERT(isolate() != NULL);
@@ skipping 53 matching lines @@
   token_streams_ = Array::null();
 }
 
 
 intptr_t FullSnapshotWriter::WriteVMSnapshot() {
   NOT_IN_PRODUCT(TimelineDurationScope tds(
       thread(), Timeline::GetIsolateStream(), "WriteVMSnapshot"));
 
   ASSERT(vm_snapshot_data_buffer_ != NULL);
   Serializer serializer(thread(), kind_, vm_snapshot_data_buffer_, alloc_,
-                        kInitialSize, vm_instructions_writer_);
+                        kInitialSize, vm_image_writer_);
 
   serializer.ReserveHeader();
   serializer.WriteVersionAndFeatures();
   // VM snapshot roots are:
   // - the symbol table
   // - all the token streams
   // - the stub code (precompiled snapshots only)
   intptr_t num_objects =
       serializer.WriteVMSnapshot(new_vm_symbol_table_, token_streams_);
   serializer.FillHeader(serializer.kind());
   clustered_vm_size_ = serializer.bytes_written();
 
   if (Snapshot::IncludesCode(kind_)) {
-    vm_instructions_writer_->Write(serializer.stream(), true);
-    mapped_data_size_ += vm_instructions_writer_->data_size();
-    mapped_instructions_size_ += vm_instructions_writer_->text_size();
-    vm_instructions_writer_->ResetOffsets();
+    vm_image_writer_->Write(serializer.stream(), true);
+    mapped_data_size_ += vm_image_writer_->data_size();
+    mapped_instructions_size_ += vm_image_writer_->text_size();
+    vm_image_writer_->ResetOffsets();
   }
 
   // The clustered part + the direct mapped data part.
   vm_isolate_snapshot_size_ = serializer.bytes_written();
   return num_objects;
 }
 
 
 void FullSnapshotWriter::WriteIsolateSnapshot(intptr_t num_base_objects) {
   NOT_IN_PRODUCT(TimelineDurationScope tds(
       thread(), Timeline::GetIsolateStream(), "WriteIsolateSnapshot"));
 
   Serializer serializer(thread(), kind_, isolate_snapshot_data_buffer_, alloc_,
-                        kInitialSize, isolate_instructions_writer_);
+                        kInitialSize, isolate_image_writer_);
   ObjectStore* object_store = isolate()->object_store();
   ASSERT(object_store != NULL);
 
   serializer.ReserveHeader();
   serializer.WriteVersionAndFeatures();
   // Isolate snapshot roots are:
   // - the object store
   serializer.WriteIsolateSnapshot(num_base_objects, object_store);
   serializer.FillHeader(serializer.kind());
   clustered_isolate_size_ = serializer.bytes_written();
 
   if (Snapshot::IncludesCode(kind_)) {
-    isolate_instructions_writer_->Write(serializer.stream(), false);
-    mapped_data_size_ += isolate_instructions_writer_->data_size();
-    mapped_instructions_size_ += isolate_instructions_writer_->text_size();
-    isolate_instructions_writer_->ResetOffsets();
+    isolate_image_writer_->Write(serializer.stream(), false);
+    mapped_data_size_ += isolate_image_writer_->data_size();
+    mapped_instructions_size_ += isolate_image_writer_->text_size();
+    isolate_image_writer_->ResetOffsets();
   }
 
   // The clustered part + the direct mapped data part.
   isolate_snapshot_size_ = serializer.bytes_written();
 }
 
 
 void FullSnapshotWriter::WriteFullSnapshot() {
   intptr_t num_base_objects;
   if (vm_snapshot_data_buffer() != NULL) {
@@ skipping 44 matching lines @@
   Deserializer deserializer(thread_, kind_, buffer_, size_,
                             instructions_buffer_, data_buffer_);
 
   RawApiError* error = deserializer.VerifyVersionAndFeatures();
   if (error != ApiError::null()) {
     return error;
   }
 
   if (Snapshot::IncludesCode(kind_)) {
     ASSERT(instructions_buffer_ != NULL);
-    thread_->isolate()->SetupInstructionsSnapshotPage(instructions_buffer_);
+    thread_->isolate()->SetupImagePage(instructions_buffer_,
+                                       /* is_executable */ true);
     ASSERT(data_buffer_ != NULL);
-    thread_->isolate()->SetupDataSnapshotPage(data_buffer_);
+    thread_->isolate()->SetupImagePage(data_buffer_,
+                                       /* is_executable */ false);
   }
 
   deserializer.ReadVMSnapshot();
 
   return ApiError::null();
 }
 
 
 RawApiError* FullSnapshotReader::ReadIsolateSnapshot() {
   Deserializer deserializer(thread_, kind_, buffer_, size_,
                             instructions_buffer_, data_buffer_);
 
   RawApiError* error = deserializer.VerifyVersionAndFeatures();
   if (error != ApiError::null()) {
     return error;
   }
 
   if (Snapshot::IncludesCode(kind_)) {
     ASSERT(instructions_buffer_ != NULL);
-    thread_->isolate()->SetupInstructionsSnapshotPage(instructions_buffer_);
+    thread_->isolate()->SetupImagePage(instructions_buffer_,
+                                       /* is_executable */ true);
     ASSERT(data_buffer_ != NULL);
-    thread_->isolate()->SetupDataSnapshotPage(data_buffer_);
+    thread_->isolate()->SetupImagePage(data_buffer_,
+                                       /* is_executable */ false);
   }
 
   deserializer.ReadIsolateSnapshot(thread_->isolate()->object_store());
 
   return ApiError::null();
 }
 
 }  // namespace dart