Option to output precompiled instructions as a blob for use with mmap instead of assembly for use i…

runtime/vm/snapshot.h

 // 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.
 
 #ifndef VM_SNAPSHOT_H_
 #define VM_SNAPSHOT_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
@@ skipping 826 matching lines @@
   GrowableArray<Node*> nodes_;
   intptr_t first_unprocessed_object_id_;
 
   friend class FullSnapshotWriter;
   DISALLOW_COPY_AND_ASSIGN(ForwardList);
 };
 
 
 class InstructionsWriter : public ZoneAllocated {
  public:
-  InstructionsWriter(uint8_t** buffer,
-                     ReAlloc alloc,
-                     intptr_t initial_size)
-    : stream_(buffer, alloc, initial_size),
-      next_offset_(InstructionsSnapshot::kHeaderSize),
+  InstructionsWriter()
+    : next_offset_(InstructionsSnapshot::kHeaderSize),
       next_object_offset_(DataSnapshot::kHeaderSize),
-      binary_size_(0),
       instructions_(),
       objects_() {
-    ASSERT(buffer != NULL);
-    ASSERT(alloc != NULL);
   }
-
-  // Size of the snapshot (assembly code).
-  intptr_t BytesWritten() const { return stream_.bytes_written(); }
-
-  intptr_t binary_size() { return binary_size_; }
+  virtual ~InstructionsWriter() { }
 
   int32_t GetOffsetFor(RawInstructions* instructions, RawCode* code);
 
   int32_t GetObjectOffsetFor(RawObject* raw_object);
 
-  void WriteAssembly();
+  virtual void Write() = 0;
+  virtual intptr_t binary_size() = 0;
 
- private:
+ protected:
   struct InstructionsData {
     explicit InstructionsData(RawInstructions* insns,
                               RawCode* code,
                               intptr_t offset)
         : raw_insns_(insns), raw_code_(code), offset_(offset) { }
 
     union {
       RawInstructions* raw_insns_;
       const Instructions* insns_;
     };
     union {
       RawCode* raw_code_;
       const Code* code_;
     };
     intptr_t offset_;
   };
 
   struct ObjectData {
     explicit ObjectData(RawObject* raw_obj)
         : raw_obj_(raw_obj) { }
 
     union {
       RawObject* raw_obj_;
       const Object* obj_;
     };
   };
 
+  intptr_t next_offset_;
+  intptr_t next_object_offset_;
+  GrowableArray<InstructionsData> instructions_;
+  GrowableArray<ObjectData> objects_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(InstructionsWriter);
+};
+
+
+class AssemblyInstructionsWriter : public InstructionsWriter {
+ public:
+  AssemblyInstructionsWriter(uint8_t** assembly_buffer,
+                             ReAlloc alloc,
+                             intptr_t initial_size)
+    : InstructionsWriter(),
+      assembly_stream_(assembly_buffer, alloc, initial_size) {
+  }
+
+  virtual void Write();
+  virtual intptr_t binary_size() { return binary_size_; }
+
+  intptr_t AssemblySize() const { return assembly_stream_.bytes_written(); }
+
+ private:
   void WriteWordLiteral(uword value) {
     // Padding is helpful for comparing the .S with --disassemble.
 #if defined(ARCH_IS_64_BIT)
-    stream_.Print(".quad 0x%0.16" Px "\n", value);
+    assembly_stream_.Print(".quad 0x%0.16" Px "\n", value);
 #else
-    stream_.Print(".long 0x%0.8" Px "\n", value);
+    assembly_stream_.Print(".long 0x%0.8" Px "\n", value);
 #endif
     binary_size_ += sizeof(value);
   }
 
-  WriteStream stream_;
-  intptr_t next_offset_;
-  intptr_t next_object_offset_;
+  WriteStream assembly_stream_;
   intptr_t binary_size_;
-  GrowableArray<InstructionsData> instructions_;
-  GrowableArray<ObjectData> objects_;
 
-  DISALLOW_COPY_AND_ASSIGN(InstructionsWriter);
+  DISALLOW_COPY_AND_ASSIGN(AssemblyInstructionsWriter);
 };
 
 
+class BlobInstructionsWriter : public InstructionsWriter {
+ public:
+  BlobInstructionsWriter(uint8_t** instructions_blob_buffer,
+                         uint8_t** rodata_blob_buffer,
+                         ReAlloc alloc,
+                         intptr_t initial_size)
+    : InstructionsWriter(),
+      instructions_blob_stream_(instructions_blob_buffer, alloc, initial_size),
+      rodata_blob_stream_(rodata_blob_buffer, alloc, initial_size) {
+  }
+
+  virtual void Write();
+  virtual intptr_t binary_size() {
+    return InstructionsBlobSize() + RodataBlobSize();
+  }
+
+  intptr_t InstructionsBlobSize() const {
+    return instructions_blob_stream_.bytes_written();
+  }
+  intptr_t RodataBlobSize() const {
+    return rodata_blob_stream_.bytes_written();
+  }
+
+ private:
+  WriteStream instructions_blob_stream_;
+  WriteStream rodata_blob_stream_;
+
+  DISALLOW_COPY_AND_ASSIGN(BlobInstructionsWriter);
+};
+
+
 class SnapshotWriter : public BaseWriter {
  protected:
   SnapshotWriter(Snapshot::Kind kind,
                  Thread* thread,
                  uint8_t** buffer,
                  ReAlloc alloc,
                  intptr_t initial_size,
                  ForwardList* forward_list,
                  InstructionsWriter* instructions_writer,
                  bool can_send_any_object,
@@ skipping 133 matching lines @@
   friend class WriteInlinedObjectVisitor;
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriter);
 };
 
 
 class FullSnapshotWriter {
  public:
   static const intptr_t kInitialSize = 64 * KB;
   FullSnapshotWriter(uint8_t** vm_isolate_snapshot_buffer,
                      uint8_t** isolate_snapshot_buffer,
-                     uint8_t** instructions_snapshot_buffer,
                      ReAlloc alloc,
+                     InstructionsWriter* instructions_writer,
                      bool snapshot_code,
                      bool vm_isolate_is_symbolic);
   ~FullSnapshotWriter();
 
   uint8_t** vm_isolate_snapshot_buffer() {
     return vm_isolate_snapshot_buffer_;
   }
 
   uint8_t** isolate_snapshot_buffer() {
     return isolate_snapshot_buffer_;
   }
 
   Thread* thread() const { return thread_; }
   Zone* zone() const { return thread_->zone(); }
   Isolate* isolate() const { return thread_->isolate(); }
   Heap* heap() const { return isolate()->heap(); }
 
   // Writes a full snapshot of the Isolate.
   void WriteFullSnapshot();
 
   intptr_t VmIsolateSnapshotSize() const {
     return vm_isolate_snapshot_size_;
   }
   intptr_t IsolateSnapshotSize() const {
     return isolate_snapshot_size_;
   }
-  intptr_t InstructionsSnapshotSize() const {
-    return instructions_snapshot_size_;
-  }
 
  private:
   // Writes a snapshot of the VM Isolate.
   void WriteVmIsolateSnapshot();
 
   // Writes a full snapshot of a regular Dart Isolate.
   void WriteIsolateFullSnapshot();
 
   Thread* thread_;
   uint8_t** vm_isolate_snapshot_buffer_;
   uint8_t** isolate_snapshot_buffer_;
-  uint8_t** instructions_snapshot_buffer_;
   ReAlloc alloc_;
   intptr_t vm_isolate_snapshot_size_;
   intptr_t isolate_snapshot_size_;
-  intptr_t instructions_snapshot_size_;
   ForwardList* forward_list_;
   InstructionsWriter* instructions_writer_;
   Array& scripts_;
   Array& symbol_table_;
   bool snapshot_code_;
   bool vm_isolate_is_symbolic_;
 
   DISALLOW_COPY_AND_ASSIGN(FullSnapshotWriter);
 };
 
 
 class PrecompiledSnapshotWriter : public FullSnapshotWriter {
  public:
   PrecompiledSnapshotWriter(uint8_t** vm_isolate_snapshot_buffer,
                             uint8_t** isolate_snapshot_buffer,
-                            uint8_t** instructions_snapshot_buffer,
-                            ReAlloc alloc);
+                            ReAlloc alloc,
+                            InstructionsWriter* instructions_writer);
   ~PrecompiledSnapshotWriter();
 };
 
 
 class ScriptSnapshotWriter : public SnapshotWriter {
  public:
   static const intptr_t kInitialSize = 64 * KB;
   ScriptSnapshotWriter(uint8_t** buffer, ReAlloc alloc);
   ~ScriptSnapshotWriter() { }
 
@@ skipping 36 matching lines @@
  private:
   SnapshotWriter* writer_;
   bool as_references_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // VM_SNAPSHOT_H_