Move the Kernel string offsets into the VM's 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 313 matching lines @@
   BlockStack<VariableDeclaration> scope_;
   BlockStack<TypeParameter> type_parameters_;
   BlockStack<SwitchCase> switch_cases_;
   BlockStack<LabeledStatement>* labels_;
 };
 
 
 class Reader {
  public:
   Reader(const uint8_t* buffer, intptr_t size)
-      : buffer_(buffer), size_(size), offset_(0), string_data_offset_(-1) {}
+      : buffer_(buffer),
+        size_(size),
+        offset_(0),
+        string_table_offset_(-1),
+        string_data_offset_(-1),
+        string_offsets_(NULL) {}
+
+  ~Reader() { delete[] string_offsets_; }
 
   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);
     offset_ += 4;
     return value;
   }
@@ skipping 152 matching lines @@
     ASSERT(name != NULL);
     return name;
   }
 
   intptr_t offset() { return offset_; }
   void set_offset(intptr_t offset) { offset_ = offset; }
   intptr_t size() { return size_; }
 
   const uint8_t* buffer() { return buffer_; }
 
+  intptr_t string_table_offset() { return string_table_offset_; }
+  void MarkStringTableOffset() {
+    ASSERT(string_table_offset_ == -1);
+    string_table_offset_ = offset_;
+  }
+
   intptr_t string_data_offset() { return string_data_offset_; }
   void MarkStringDataOffset() {
     ASSERT(string_data_offset_ == -1);
     string_data_offset_ = offset_;
   }
 
-  uint8_t CharacterAt(String* str, intptr_t index) {
-    ASSERT(index < str->size());
-    return buffer_[string_data_offset_ + str->offset() + index];
+  intptr_t StringLength(intptr_t string_index) {
+    return string_offsets_[string_index + 1] - string_offsets_[string_index];
+  }
+
+  uint8_t CharacterAt(intptr_t string_index, intptr_t index) {
+    ASSERT(index < StringLength(string_index));
+    return buffer_[string_data_offset_ + string_offsets_[string_index] + index];
   }
 
  private:
   const uint8_t* buffer_;
   intptr_t size_;
   intptr_t offset_;
   ReaderHelper builder_;
   TokenPosition max_position_;
   TokenPosition min_position_;
   intptr_t current_script_id_;
 
+  // When the binary is deserialized the offset of the start of the string table
+  // (the length) and the offset of the start of the string data are recorded.
+  intptr_t string_table_offset_;
   intptr_t string_data_offset_;
 
+  // The string offsets are decoded to support efficient access to string UTF-8
+  // encodings.
+  intptr_t* string_offsets_;
+
   friend class PositionScope;
+  friend class Program;
 };
 
 
 // A helper class that resets the readers min and max positions both upon
 // initialization and upon destruction, i.e. when created the min an max
 // positions will be reset to "noSource", when destructing the min and max will
 // be reset to have they value they would have had, if they hadn't been reset in
 // the first place.
 class PositionScope {
  public:
@@ skipping 17 matching lines @@
   Reader* reader_;
   TokenPosition min_;
   TokenPosition max_;
 };
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_BINARY_H_