Emit assembly instead of a blob for the instructions snapshot, and provide labels for the entry poi…

runtime/vm/datastream.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_DATASTREAM_H_
 #define VM_DATASTREAM_H_
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/allocation.h"
 #include "vm/exceptions.h"
 #include "vm/globals.h"
+#include "vm/os.h"
 
 namespace dart {
 
 static const int8_t kDataBitsPerByte = 7;
 static const int8_t kByteMask = (1 << kDataBitsPerByte) - 1;
 static const int8_t kMaxUnsignedDataPerByte = kByteMask;
 static const int8_t kMinDataPerByte = -(1 << (kDataBitsPerByte - 1));
 static const int8_t kMaxDataPerByte = (~kMinDataPerByte & kByteMask);  // NOLINT
 static const uint8_t kEndByteMarker = (255 - kMaxDataPerByte);
 static const uint8_t kEndUnsignedByteMarker = (255 - kMaxUnsignedDataPerByte);
@@ skipping 356 matching lines @@
 
   void WriteBytes(const uint8_t* addr, intptr_t len) {
     if ((end_ - current_) < len) {
       Resize(len);
     }
     ASSERT((end_ - current_) >= len);
     memmove(current_, addr, len);
     current_ += len;
   }
 
+  void Print(const char* format, ...) {
+    va_list args;
+    va_start(args, format);
+    VPrint(format, args);
+  }
+
  private:
   template<typename T>
   void Write(T value) {
     T v = value;
     while (v < kMinDataPerByte ||
            v > kMaxDataPerByte) {
       WriteByte(static_cast<uint8_t>(v & kByteMask));
       v = v >> kDataBitsPerByte;
     }
     WriteByte(static_cast<uint8_t>(v + kEndByteMarker));
@@ skipping 20 matching lines @@
                                                  new_size));
     if (*buffer_ == NULL) {
       Exceptions::ThrowOOM();
     }
     current_ = *buffer_ + position;
     current_size_ = new_size;
     end_ = *buffer_ + new_size;
     ASSERT(end_ > *buffer_);
   }
 
+  void VPrint(const char* format, va_list args) {
+    // Measure.
+    va_list measure_args;
+    va_copy(measure_args, args);
+    intptr_t len = OS::VSNPrint(NULL, 0, format, measure_args);
+    va_end(measure_args);
+
+    // Alloc.
+    if ((end_ - current_) < (len + 1)) {
+      Resize(len + 1);
+    }
+    ASSERT((end_ - current_) >= (len + 1));
+
+    // Print.
+    va_list print_args;
+    va_copy(print_args, args);
+    OS::VSNPrint(reinterpret_cast<char*>(current_),
+                 len + 1, format, print_args);
+    va_end(print_args);
+    current_ += len;  // Not len + 1 to swallow the terminating NUL.
+  }
+
  private:
   uint8_t** const buffer_;
   uint8_t* end_;
   uint8_t* current_;
   intptr_t current_size_;
   ReAlloc alloc_;
   intptr_t initial_size_;
 
   DISALLOW_COPY_AND_ASSIGN(WriteStream);
 };
 
 }  // namespace dart
 
 #endif  // VM_DATASTREAM_H_