Move the Kernel string offsets into the VM's heap.

runtime/vm/kernel_reader.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.
 
 #include "vm/kernel_reader.h"
 
 #include <string.h>
 
 #include "vm/dart_api_impl.h"
+#include "vm/kernel_binary.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/symbols.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 namespace dart {
 namespace kernel {
 
 #define Z (zone_)
@@ skipping 91 matching lines @@
       zone_(thread_->zone()),
       isolate_(thread_->isolate()),
       scripts_(Array::ZoneHandle(zone_)),
       translation_helper_(this, thread_),
       type_translator_(&translation_helper_,
                        &active_class_,
                        /*finalize=*/false) {
   intptr_t source_file_count = program->source_table().size();
   scripts_ = Array::New(source_file_count, Heap::kOld);
 
-  // Copy the Kernel strings out of the binary and into the VM's heap.  The size
-  // of the string data can be computed from the offset and size of the last
-  // string.  This relies on the strings occurring in order in the program's
-  // string table.
-  List<String>& strings = program->string_table().strings();
-  String* last_string = strings[strings.length() - 1];
-  intptr_t size = last_string->offset() + last_string->size();
-  TypedData& data = TypedData::Handle(
-      Z, TypedData::New(kTypedDataUint8ArrayCid, size, Heap::kOld));
-  ASSERT(program->string_data_offset() >= 0);
   // We need at least one library to get access to the binary.
   ASSERT(program->libraries().length() > 0);
+  Library* library = program->libraries()[0];
+  Reader reader(library->kernel_data(), library->kernel_data_size());
+
+  // Copy the Kernel string offsets out of the binary and into the VM's heap.
+  ASSERT(program->string_table_offset() >= 0);
+  reader.set_offset(program->string_table_offset());
+  intptr_t count = reader.ReadUInt() + 1;
+  TypedData& offsets = TypedData::Handle(
+      Z, TypedData::New(kTypedDataUint32ArrayCid, count, Heap::kOld));
+  offsets.SetUint32(0, 0);
+  intptr_t end_offset = 0;
+  for (intptr_t i = 1; i < count; ++i) {
+    end_offset = reader.ReadUInt();
+    offsets.SetUint32(i << 2, end_offset);
+  }
+
+  // Copy the string data out of the binary and into the VM's heap.
+  TypedData& data = TypedData::Handle(
+      Z, TypedData::New(kTypedDataUint8ArrayCid, end_offset, Heap::kOld));
   {
     NoSafepointScope no_safepoint;
-    memmove(data.DataAddr(0), program->libraries()[0]->kernel_data() +
-                                  program->string_data_offset(),
-            size);
+    memmove(data.DataAddr(0), reader.buffer() + reader.offset(), end_offset);
   }
+  H.SetStringOffsets(offsets);
   H.SetStringData(data);
 }
 
 
 Object& KernelReader::ReadProgram() {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     intptr_t length = program_->libraries().length();
     for (intptr_t i = 0; i < length; i++) {
       Library* kernel_library = program_->libraries()[i];
@@ skipping 331 matching lines @@
     // Maybe it has a native implementation, which is not external as far as
     // the VM is concerned because it does have an implementation.  Check for
     // an ExternalName annotation and extract the string from it.
     for (int i = 0; i < kernel_procedure->annotations().length(); ++i) {
       Expression* annotation = kernel_procedure->annotations()[i];
       if (!annotation->IsConstructorInvocation()) continue;
       ConstructorInvocation* invocation =
           ConstructorInvocation::Cast(annotation);
       CanonicalName* annotation_class = H.EnclosingName(invocation->target());
       ASSERT(H.IsClass(annotation_class));
-      String* class_name = annotation_class->name();
+      intptr_t class_name_index = annotation_class->name();
       // Just compare by name, do not generate the annotation class.
-      if (!H.StringEquals(class_name, "ExternalName")) continue;
+      if (!H.StringEquals(class_name_index, "ExternalName")) continue;
       ASSERT(H.IsLibrary(annotation_class->parent()));
-      String* library_name = annotation_class->parent()->name();
-      if (!H.StringEquals(library_name, "dart:_internal")) continue;
+      intptr_t library_name_index = annotation_class->parent()->name();
+      if (!H.StringEquals(library_name_index, "dart:_internal")) continue;
 
       is_external = false;
       ASSERT(invocation->arguments()->positional().length() == 1 &&
              invocation->arguments()->named().length() == 0);
       StringLiteral* literal =
           StringLiteral::Cast(invocation->arguments()->positional()[0]);
       native_name = &H.DartSymbol(literal->value());
       break;
     }
   }
@@ skipping 94 matching lines @@
     for (intptr_t i = 0; i <= last; ++i) {
       smi_value = Smi::New(source->At(i));
       array_object.SetAt(i, smi_value);
     }
     return array_object.raw();
   } else {
     return Array::New(0);
   }
 }
 
-Script& KernelReader::ScriptAt(intptr_t index, String* import_uri) {
+Script& KernelReader::ScriptAt(intptr_t index, intptr_t import_uri) {
   Script& script = Script::ZoneHandle(Z);
   script ^= scripts_.At(index);
   if (script.IsNull()) {
     // Create script with correct uri(s).
     uint8_t* uri_buffer = program_->source_table().UriFor(index);
     intptr_t uri_size = program_->source_table().UriSizeFor(index);
     dart::String& uri_string = H.DartString(uri_buffer, uri_size, Heap::kOld);
     dart::String& import_uri_string =
-        import_uri == NULL ? uri_string : H.DartString(import_uri, Heap::kOld);
+        import_uri == -1 ? uri_string : H.DartString(import_uri, Heap::kOld);
     uint8_t* source_buffer = program_->source_table().SourceCodeFor(index);
     intptr_t source_size = program_->source_table().SourceCodeSizeFor(index);
     dart::String& source_code =
         H.DartString(source_buffer, source_size, Heap::kOld);
     script = Script::New(import_uri_string, uri_string, source_code,
                          RawScript::kKernelTag);
-    script.set_kernel_strings(H.string_data());
+    script.set_kernel_string_offsets(H.string_offsets());
+    script.set_kernel_string_data(H.string_data());
     scripts_.SetAt(index, script);
 
     // Create line_starts array for the script.
     intptr_t* line_starts = program_->source_table().LineStartsFor(index);
     intptr_t line_count = program_->source_table().LineCountFor(index);
     Array& array_object = Array::Handle(Z, Array::New(line_count, Heap::kOld));
     Smi& value = Smi::Handle(Z);
     for (intptr_t i = 0; i < line_count; ++i) {
       value = Smi::New(line_starts[i]);
       array_object.SetAt(i, value);
@@ skipping 280 matching lines @@
   initializer_fun.set_is_debuggable(false);
   initializer_fun.set_is_reflectable(false);
   initializer_fun.set_is_inlinable(false);
   return new (zone) ParsedFunction(thread, initializer_fun);
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)