[kernel] Insert kernel bodies into VM heap

runtime/vm/kernel_binary.h

 // Copyright (c) 2017, 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 RUNTIME_VM_KERNEL_BINARY_H_
 #define RUNTIME_VM_KERNEL_BINARY_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include <map>
@@ skipping 119 matching lines @@
   kSpecializedVariableGet = 128,
   kSpecializedVariableSet = 136,
   kSpecialIntLiteral = 144,
 };
 
 static const int SpecializedIntLiteralBias = 3;
 
 class Reader {
  public:
   Reader(const uint8_t* buffer, intptr_t size)
-      : buffer_(buffer), size_(size), offset_(0) {}
+      : raw_buffer_(buffer), typed_data_(NULL), size_(size), offset_(0) {}
+
+  explicit Reader(const TypedData& typed_data)
+      : raw_buffer_(NULL),
+        typed_data_(&typed_data),
+        size_(typed_data.IsNull() ? 0 : typed_data.Length()),
+        offset_(0) {}
 
   uint32_t ReadUInt32() {
     ASSERT(offset_ + 4 <= size_);
 
-    uint32_t value = (buffer_[offset_ + 0] << 24) |
-                     (buffer_[offset_ + 1] << 16) |
-                     (buffer_[offset_ + 2] << 8) | (buffer_[offset_ + 3] << 0);
+    const uint8_t* buffer = this->buffer();
+    uint32_t value = (buffer[offset_ + 0] << 24) | (buffer[offset_ + 1] << 16) |
+                     (buffer[offset_ + 2] << 8) | (buffer[offset_ + 3] << 0);
     offset_ += 4;
     return value;
   }
 
   uint32_t ReadUInt() {
     ASSERT(offset_ + 1 <= size_);
-    uint8_t byte0 = buffer_[offset_];
+
+    const uint8_t* buffer = this->buffer();
+    uint8_t byte0 = buffer[offset_];
     if ((byte0 & 0x80) == 0) {
       // 0...
       offset_++;
       return byte0;
     } else if ((byte0 & 0xc0) == 0x80) {
       // 10...
       ASSERT(offset_ + 2 <= size_);
-      uint32_t value = ((byte0 & ~0x80) << 8) | (buffer_[offset_ + 1]);
+      uint32_t value = ((byte0 & ~0x80) << 8) | (buffer[offset_ + 1]);
       offset_ += 2;
       return value;
     } else {
       // 11...
       ASSERT(offset_ + 4 <= size_);
-      uint32_t value = ((byte0 & ~0xc0) << 24) | (buffer_[offset_ + 1] << 16) |
-                       (buffer_[offset_ + 2] << 8) |
-                       (buffer_[offset_ + 3] << 0);
+      uint32_t value = ((byte0 & ~0xc0) << 24) | (buffer[offset_ + 1] << 16) |
+                       (buffer[offset_ + 2] << 8) | (buffer[offset_ + 3] << 0);
       offset_ += 4;
       return value;
     }
   }
 
   /**
    * Read and return a TokenPosition from this reader.
-   * @param record specifies whether or not the read position is saved as a
-   * valid token position in the current script.
-   * If not be sure to record it later by calling record_token_position (after
-   * setting the correct current_script_id).
    */
   TokenPosition ReadPosition() {
     // Position is saved as unsigned,
     // but actually ranges from -1 and up (thus the -1)
     intptr_t value = ReadUInt() - 1;
     TokenPosition result = TokenPosition(value);
     max_position_ = Utils::Maximum(max_position_, result);
     if (min_position_.IsNoSource()) {
       min_position_ = result;
     } else if (result.IsReal()) {
       min_position_ = Utils::Minimum(min_position_, result);
     }
 
     return result;
   }
 
   intptr_t ReadListLength() { return ReadUInt(); }
 
-  uint8_t ReadByte() { return buffer_[offset_++]; }
+  uint8_t ReadByte() { return buffer()[offset_++]; }
 
-  uint8_t PeekByte() { return buffer_[offset_]; }
+  uint8_t PeekByte() { return buffer()[offset_]; }
 
   bool ReadBool() { return (ReadByte() & 1) == 1; }
 
   word ReadFlags() { return ReadByte(); }
 
   Tag ReadTag(uint8_t* payload = NULL) {
     uint8_t byte = ReadByte();
     bool has_payload = (byte & kSpecializedTagHighBit) != 0;
     if (has_payload) {
       if (payload != NULL) {
@@ skipping 11 matching lines @@
     if (has_payload) {
       if (payload != NULL) {
         *payload = byte & kSpecializedPayloadMask;
       }
       return static_cast<Tag>(byte & kSpecializedTagMask);
     } else {
       return static_cast<Tag>(byte);
     }
   }
 
-  const uint8_t* Consume(int count) {
-    ASSERT(offset_ + count <= size_);
-    const uint8_t* old = buffer_ + offset_;
-    offset_ += count;
-    return old;
-  }
-
   void EnsureEnd() {
     if (offset_ != size_) {
       FATAL2(
           "Reading Kernel file: Expected to be at EOF "
           "(offset: %" Pd ", size: %" Pd ")",
           offset_, size_);
     }
   }
 
   // The largest position read yet (since last reset).
   // This is automatically updated when calling ReadPosition,
   // but can be overwritten (e.g. via the PositionScope class).
   TokenPosition max_position() { return max_position_; }
   // The smallest position read yet (since last reset).
   // This is automatically updated when calling ReadPosition,
   // but can be overwritten (e.g. via the PositionScope class).
   TokenPosition min_position() { return min_position_; }
 
-  template <typename T, typename RT>
-  T* ReadOptional() {
-    Tag tag = ReadTag();
-    if (tag == kNothing) {
-      return NULL;
-    }
-    ASSERT(tag == kSomething);
-    return RT::ReadFrom(this);
-  }
-
-  template <typename T>
-  T* ReadOptional() {
-    return ReadOptional<T, T>();
-  }
-
   // A canonical name reference of -1 indicates none (for optional names), not
   // the root name as in the canonical name table.
   NameIndex ReadCanonicalNameReference() { return NameIndex(ReadUInt() - 1); }
 
   intptr_t offset() { return offset_; }
   void set_offset(intptr_t offset) { offset_ = offset; }
+
   intptr_t size() { return size_; }
+  void set_size(intptr_t size) { size_ = size; }
 
-  const uint8_t* buffer() { return buffer_; }
+  const TypedData* typed_data() { return typed_data_; }
+  void set_typed_data(const TypedData* typed_data) { typed_data_ = typed_data; }
+
+  const uint8_t* raw_buffer() { return raw_buffer_; }
+  void set_raw_buffer(const uint8_t* raw_buffer) { raw_buffer_ = raw_buffer; }
+
+  TypedData& CopyDataToVMHeap(Zone* zone,
+                              intptr_t from_byte,
+                              intptr_t to_byte) {
+    intptr_t size = to_byte - from_byte;
+    TypedData& data = TypedData::Handle(
+        zone, TypedData::New(kTypedDataUint8ArrayCid, size, Heap::kOld));
+    {
+      NoSafepointScope no_safepoint;
+      memmove(data.DataAddr(0), buffer() + from_byte, size);
+    }
+    return data;
+  }
+
+  uint8_t* CopyDataIntoZone(Zone* zone, intptr_t offset, intptr_t length) {
+    uint8_t* buffer_ = zone->Alloc<uint8_t>(length);
+    {
+      NoSafepointScope no_safepoint;
+      memmove(buffer_, buffer() + offset, length);
+    }
+    return buffer_;
+  }
 
  private:
-  const uint8_t* buffer_;
+  const uint8_t* buffer() {
+    if (raw_buffer_ != NULL) {
+      return raw_buffer_;
+    }
+    NoSafepointScope no_safepoint;
+    return reinterpret_cast<uint8_t*>(typed_data_->DataAddr(0));
+  }
+
+  const uint8_t* raw_buffer_;
+  const TypedData* typed_data_;
   intptr_t size_;
   intptr_t offset_;
   TokenPosition max_position_;
   TokenPosition min_position_;
   intptr_t current_script_id_;
 
   friend class PositionScope;
   friend class Program;
 };
 
@@ skipping 24 matching lines @@
   Reader* reader_;
   TokenPosition min_;
   TokenPosition max_;
 };
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_BINARY_H_