Move Kernel strings into the VM's heap.

runtime/vm/kernel_binary.cc

 // Copyright (c) 2016, 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.
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/kernel_binary.h"
 #include "platform/globals.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/kernel.h"
@@ skipping 88 matching lines @@
 template <typename B, typename S>
 class DowncastReader {
  public:
   static S* ReadFrom(Reader* reader) {
     TRACE_READ_OFFSET();
     return S::Cast(B::ReadFrom(reader));
   }
 };
 
 
-class StringImpl {
- public:
-  static String* ReadFrom(Reader* reader) {
-    TRACE_READ_OFFSET();
-    return String::ReadFromImpl(reader);
-  }
-};
-
-
 class VariableDeclarationImpl {
  public:
   static VariableDeclaration* ReadFrom(Reader* reader) {
     TRACE_READ_OFFSET();
     return VariableDeclaration::ReadFromImpl(reader, false);
   }
 };
 
 
 String* String::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   return Reference::ReadStringFrom(reader);
 }
 
 
-String* String::ReadFromImpl(Reader* reader) {
-  TRACE_READ_OFFSET();
-  intptr_t size = reader->ReadUInt();
-  return ReadRaw(reader, size);
-}
-
-
 String* String::ReadRaw(Reader* reader, intptr_t size) {
-  return new String(reader->Consume(size), size);
+  ASSERT(reader->string_data_offset() >= 0);
+  String* result =
+      new String(reader->offset() - reader->string_data_offset(), size);
+  reader->Consume(size);
+  return result;
 }
 
 
 void StringTable::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   // Read the table of end offsets.
   intptr_t length = reader->ReadUInt();
-  int* end_offsets = new int[length];
+  intptr_t* end_offsets = new intptr_t[length];
   for (intptr_t i = 0; i < length; ++i) {
     end_offsets[i] = reader->ReadUInt();
   }
   // Read the UTF-8 encoded strings.
+  reader->MarkStringDataOffset();
   strings_.EnsureInitialized(length);
   intptr_t start_offset = 0;
   for (intptr_t i = 0; i < length; ++i) {
     ASSERT(strings_[i] == NULL);
     strings_[i] = String::ReadRaw(reader, end_offsets[i] - start_offset);
     start_offset = end_offsets[i];
   }
   delete[] end_offsets;
 }
 
 
 void SourceTable::ReadFrom(Reader* reader) {
-  size_ = reader->helper()->program()->source_uri_table().strings().length();
-  source_code_ = new String*[size_];
-  line_starts_ = new intptr_t*[size_];
-  line_count_ = new intptr_t[size_];
+  size_ = reader->ReadUInt();
+  sources_ = new Source[size_];
+
+  // Build a table of the URI offsets.
+  intptr_t* end_offsets = new intptr_t[size_];
   for (intptr_t i = 0; i < size_; ++i) {
-    source_code_[i] = StringImpl::ReadFrom(reader);
+    end_offsets[i] = reader->ReadUInt();
+  }
+
+  // Read the URI strings.
+  intptr_t start_offset = 0;
+  for (intptr_t i = 0; i < size_; ++i) {
+    intptr_t length = end_offsets[i] - start_offset;
+    uint8_t* buffer = new uint8_t[length];
+    memmove(buffer, reader->buffer() + reader->offset(), length);
+    reader->Consume(length);
+
+    sources_[i].uri_ = buffer;
+    sources_[i].uri_size_ = length;
+
+    start_offset = end_offsets[i];
+  }
+
+  // Read the source code strings and line starts.
+  for (intptr_t i = 0; i < size_; ++i) {
+    intptr_t length = reader->ReadUInt();
+    uint8_t* string_buffer = new uint8_t[length];
+    memmove(string_buffer, reader->buffer() + reader->offset(), length);
+    reader->Consume(length);
     intptr_t line_count = reader->ReadUInt();
     intptr_t* line_starts = new intptr_t[line_count];
-    line_count_[i] = line_count;
     intptr_t previous_line_start = 0;
     for (intptr_t j = 0; j < line_count; ++j) {
       intptr_t line_start = reader->ReadUInt() + previous_line_start;
       line_starts[j] = line_start;
       previous_line_start = line_start;
     }
-    line_starts_[i] = line_starts;
+
+    sources_[i].source_code_ = string_buffer;
+    sources_[i].source_code_size_ = length;
+    sources_[i].line_starts_ = line_starts;
+    sources_[i].line_count_ = line_count;
   }
 }
 
 
 Library* Library::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   int flags = reader->ReadFlags();
   ASSERT(flags == 0);  // external libraries not supported
   kernel_data_ = reader->buffer();
   kernel_data_size_ = reader->size();
@@ skipping 1166 matching lines @@
   decl->position_ = reader->ReadPosition();
   decl->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
   VariableScope<ReaderHelper> parameters(reader->helper());
   decl->function_ = FunctionNode::ReadFrom(reader);
   return decl;
 }
 
 
 Name* Name::ReadFrom(Reader* reader) {
   String* name = Reference::ReadStringFrom(reader);
-  if (name->size() >= 1 && name->buffer()[0] == '_') {
+  if (name->size() >= 1 && reader->CharacterAt(name, 0) == '_') {
     CanonicalName* library_reference = reader->ReadCanonicalNameReference();
     return new Name(name, library_reference);
   } else {
     return new Name(name, NULL);
   }
 }
 
 
 DartType* DartType::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
@@ skipping 105 matching lines @@
 Program* Program::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   uint32_t magic = reader->ReadUInt32();
   if (magic != kMagicProgramFile) FATAL("Invalid magic identifier");
 
   Program* program = new Program();
   program->canonical_name_root_ = CanonicalName::NewRoot();
   reader->helper()->set_program(program);
 
   program->string_table_.ReadFrom(reader);
-  program->source_uri_table_.ReadFrom(reader);
+  program->string_data_offset_ = reader->string_data_offset();
+  ASSERT(program->string_data_offset_ >= 0);
   program->source_table_.ReadFrom(reader);
 
   int canonical_names = reader->ReadUInt();
   reader->helper()->SetCanonicalNameCount(canonical_names);
   for (int i = 0; i < canonical_names; ++i) {
     int biased_parent_index = reader->ReadUInt();
     CanonicalName* parent;
     if (biased_parent_index != 0) {
       parent = reader->helper()->GetCanonicalName(biased_parent_index - 1);
     } else {
@@ skipping 58 matching lines @@
 
 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer,
                                                  intptr_t buffer_length) {
   kernel::Reader reader(buffer, buffer_length);
   return kernel::Program::ReadFrom(&reader);
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)