Move Kernel strings 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/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_)
 #define I (isolate_)
 #define T (type_translator_)
 #define H (translation_helper_)
 
 class SimpleExpressionConverter : public ExpressionVisitor {
  public:
-  explicit SimpleExpressionConverter(Thread* thread)
-      : translation_helper_(thread),
+  explicit SimpleExpressionConverter(TranslationHelper* helper)
+      : translation_helper_(*helper),
         zone_(translation_helper_.zone()),
         is_simple_(false),
         simple_value_(NULL) {}
 
   virtual void VisitDefaultExpression(Expression* node) { is_simple_ = false; }
 
   virtual void VisitIntLiteral(IntLiteral* node) {
     is_simple_ = true;
     simple_value_ =
         &Integer::ZoneHandle(Z, Integer::New(node->value(), Heap::kOld));
@@ skipping 31 matching lines @@
 
   bool IsSimple(Expression* expression) {
     expression->AcceptExpressionVisitor(this);
     return is_simple_;
   }
 
   const dart::Instance& SimpleValue() { return *simple_value_; }
   dart::Zone* zone() const { return zone_; }
 
  private:
-  TranslationHelper translation_helper_;
+  TranslationHelper& translation_helper_;
   dart::Zone* zone_;
   bool is_simple_;
   dart::Instance* simple_value_;
 };
 
 
 RawArray* KernelReader::MakeFunctionsArray() {
   const intptr_t len = functions_.length();
   const Array& res = Array::Handle(zone_, Array::New(len, Heap::kOld));
   for (intptr_t i = 0; i < len; i++) {
     res.SetAt(i, *functions_[i]);
   }
   return res.raw();
 }
 
 
 RawLibrary* BuildingTranslationHelper::LookupLibraryByKernelLibrary(
     CanonicalName* library) {
   return reader_->LookupLibrary(library).raw();
 }
 
 
 RawClass* BuildingTranslationHelper::LookupClassByKernelClass(
     CanonicalName* klass) {
   return reader_->LookupClass(klass).raw();
 }
 
+
 KernelReader::KernelReader(Program* program)
     : program_(program),
       thread_(dart::Thread::Current()),
       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();
+  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);
+  {
+    NoSafepointScope no_safepoint;
+    memmove(data.DataAddr(0), program->libraries()[0]->kernel_data() +
+                                  program->string_data_offset(),
+            size);
+  }
+  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];
       ReadLibrary(kernel_library);
     }
 
     for (intptr_t i = 0; i < length; i++) {
       dart::Library& library =
           LookupLibrary(program_->libraries()[i]->canonical_name());
       if (!library.Loaded()) library.SetLoaded();
     }
 
     if (ClassFinalizer::ProcessPendingClasses(/*from_kernel=*/true)) {
       CanonicalName* main = program_->main_method();
-      dart::Library& library = LookupLibrary(main->EnclosingName());
+      dart::Library& library = LookupLibrary(H.EnclosingName(main));
 
       // Sanity check that we can find the main entrypoint.
       Object& main_obj = Object::Handle(
           Z, library.LookupObjectAllowPrivate(H.DartSymbol("main")));
       ASSERT(!main_obj.IsNull());
       return library;
     }
   }
 
   // Either class finalization failed or we caught a compile error.
@@ skipping 272 matching lines @@
   dart::String* native_name = NULL;
   if (is_external) {
     // 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 = invocation->target()->EnclosingName();
-      ASSERT(annotation_class->IsClass());
+      CanonicalName* annotation_class = H.EnclosingName(invocation->target());
+      ASSERT(H.IsClass(annotation_class));
       String* class_name = annotation_class->name();
       // Just compare by name, do not generate the annotation class.
-      int length = sizeof("ExternalName") - 1;
-      if (class_name->size() != length) continue;
-      if (memcmp(class_name->buffer(), "ExternalName", length) != 0) continue;
-      ASSERT(annotation_class->parent()->IsLibrary());
+      if (!H.StringEquals(class_name, "ExternalName")) continue;
+      ASSERT(H.IsLibrary(annotation_class->parent()));
       String* library_name = annotation_class->parent()->name();
-      length = sizeof("dart:_internal") - 1;
-      if (library_name->size() != length) continue;
-      if (memcmp(library_name->buffer(), "dart:_internal", length) != 0) {
-        continue;
-      }
+      if (!H.StringEquals(library_name, "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 82 matching lines @@
     source->Sort(LowestFirst);
 
     intptr_t size = source->length();
     intptr_t last = 0;
     for (intptr_t current = 1; current < size; ++current) {
       if (source->At(last) != source->At(current)) {
         (*source)[++last] = source->At(current);
       }
     }
     Array& array_object = Array::Handle();
-    array_object ^= Array::New(last + 1, Heap::kOld);
+    array_object = Array::New(last + 1, Heap::kOld);
     Smi& smi_value = Smi::Handle();
     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 source_uri_index, String* import_uri) {
+Script& KernelReader::ScriptAt(intptr_t index, String* import_uri) {
   Script& script = Script::ZoneHandle(Z);
-  script ^= scripts_.At(source_uri_index);
+  script ^= scripts_.At(index);
   if (script.IsNull()) {
     // Create script with correct uri(s).
-    String* uri = program_->source_uri_table().strings()[source_uri_index];
-    dart::String& uri_string = H.DartString(uri, Heap::kOld);
+    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);
-    dart::String& source_code = H.DartString(
-        program_->source_table().SourceFor(source_uri_index), 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);
-    scripts_.SetAt(source_uri_index, script);
+    script.set_kernel_strings(H.string_data());
+    scripts_.SetAt(index, script);
 
     // Create line_starts array for the script.
-    intptr_t* line_starts =
-        program_->source_table().LineStartsFor(source_uri_index);
-    intptr_t line_count =
-        program_->source_table().LineCountFor(source_uri_index);
+    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);
     }
     script.set_line_starts(array_object);
 
     // Create tokens_seen array for the script.
-    array_object ^= AsSortedDuplicateFreeArray(
-        source_uri_index, &program_->valid_token_positions);
+    array_object =
+        AsSortedDuplicateFreeArray(index, &program_->valid_token_positions);
     script.set_debug_positions(array_object);
 
     // Create yield_positions array for the script.
-    array_object ^= AsSortedDuplicateFreeArray(
-        source_uri_index, &program_->yield_token_positions);
+    array_object =
+        AsSortedDuplicateFreeArray(index, &program_->yield_token_positions);
     script.set_yield_positions(array_object);
   }
   return script;
 }
 
 void KernelReader::GenerateFieldAccessors(const dart::Class& klass,
                                           const dart::Field& field,
                                           Field* kernel_field) {
   if (kernel_field->IsStatic() && kernel_field->initializer() == NULL) {
     // Static fields without an initializer are implicitly initialized to null.
     // We do not need a getter.
     field.SetStaticValue(Instance::Handle(Z), true);
     return;
   }
   if (kernel_field->initializer() != NULL) {
-    SimpleExpressionConverter converter(H.thread());
+    SimpleExpressionConverter converter(&H);
     const bool has_simple_initializer =
         converter.IsSimple(kernel_field->initializer());
     if (kernel_field->IsStatic()) {
       // Static fields with initializers either have the static value set to the
       // initializer value if it is simple enough or else set to an
       // uninitialized sentinel.
       if (has_simple_initializer) {
         // We do not need a getter.
         field.SetStaticValue(converter.SimpleValue(), true);
         return;
@@ skipping 243 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)