Move the Kernel canonical name table 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 294 matching lines @@
   Program* program() { return program_; }
   void set_program(Program* program) { program_ = program; }
 
   BlockStack<VariableDeclaration>& variables() { return scope_; }
   BlockStack<TypeParameter>& type_parameters() { return type_parameters_; }
   BlockStack<SwitchCase>& switch_cases() { return switch_cases_; }
 
   BlockStack<LabeledStatement>* labels() { return labels_; }
   void set_labels(BlockStack<LabeledStatement>* labels) { labels_ = labels; }
 
-  CanonicalName* GetCanonicalName(int index) { return canonical_names_[index]; }
-  void SetCanonicalName(int index, CanonicalName* name) {
-    canonical_names_[index] = name;
-  }
-  void SetCanonicalNameCount(int count) { canonical_names_.SetLength(count); }
-
  private:
   Program* program_;
-  MallocGrowableArray<CanonicalName*> canonical_names_;
   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_table_offset_(-1),
         string_data_offset_(-1),
-        string_offsets_(NULL) {}
+        string_offsets_(NULL),
+        canonical_name_parents_(NULL),
+        canonical_name_strings_(NULL) {}
 
-  ~Reader() { delete[] string_offsets_; }
+  ~Reader();
 
   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 138 matching lines @@
     return RT::ReadFrom(this);
   }
 
   template <typename T>
   T* ReadOptional() {
     return ReadOptional<T, T>();
   }
 
   ReaderHelper* helper() { return &builder_; }
 
-  CanonicalName* ReadCanonicalNameReference() {
-    int index = ReadUInt();
-    if (index == 0) return NULL;
-    CanonicalName* name = builder_.GetCanonicalName(index - 1);
-    ASSERT(name != NULL);
-    return name;
-  }
+  // A canonical name reference of -1 indicates none (for optional names), not
+  // the root name as in the canonical name table.
+  intptr_t ReadCanonicalNameReference() { return ReadUInt() - 1; }
 
   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_;
   }
 
   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];
   }
 
+  // The canonical name index of a canonical name's parent (-1 indicates that
+  // the parent is the root name).
+  intptr_t CanonicalNameParent(intptr_t name_index) {
+    return canonical_name_parents_[name_index];
+  }
+
+  // The string index of a canonical name's name string.
+  intptr_t CanonicalNameString(intptr_t name_index) {
+    return canonical_name_strings_[name_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_;
+  // The offset of the start of the string data is recorded to allow access to
+  // the strings during deserialization.
   intptr_t string_data_offset_;
 
   // The string offsets are decoded to support efficient access to string UTF-8
   // encodings.
   intptr_t* string_offsets_;
 
+  // The canonical names are decoded.
+  intptr_t* canonical_name_parents_;
+  intptr_t* canonical_name_strings_;
+
   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.
@@ skipping 19 matching lines @@
   Reader* reader_;
   TokenPosition min_;
   TokenPosition max_;
 };
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_BINARY_H_