Move the Kernel canonical name table 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"
@@ skipping 77 matching lines @@
   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) {
+    intptr_t library) {
   return reader_->LookupLibrary(library).raw();
 }
 
 
-RawClass* BuildingTranslationHelper::LookupClassByKernelClass(
-    CanonicalName* klass) {
+RawClass* BuildingTranslationHelper::LookupClassByKernelClass(intptr_t klass) {

[Vyacheslav Egorov (Google), 2017/05/03 06:28:48]

I think we *do* need need named type for these indices, otherwise it is hard to
understand whether it is a CanonicalName or maybe a String index - just by
looking at the signature. 

   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_)),
@@ skipping 22 matching lines @@
     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), reader.buffer() + reader.offset(), end_offset);
   }
+
+  // Copy the canonical names into the VM's heap.  Encode them as unsigned, so
+  // the parent indexes are adjusted when extracted.
+  reader.set_offset(program->name_table_offset());
+  count = reader.ReadUInt() * 2;
+  TypedData& names = TypedData::Handle(
+      Z, TypedData::New(kTypedDataUint32ArrayCid, count, Heap::kOld));
+  for (intptr_t i = 0; i < count; ++i) {
+    names.SetUint32(i << 2, reader.ReadUInt());
+  }
+
   H.SetStringOffsets(offsets);
   H.SetStringData(data);
+  H.SetCanonicalNames(names);
 }
 
 
 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)) {
       // There is a function _getMainClosure in dart:_builtin that returns the
       // main procedure.  Since the platform libraries are compiled before the
       // program script, this function might need to be patched here.
 
       // If there is no main method then we have compiled a partial Kernel file
       // and do not need to patch here.
-      CanonicalName* main = program_->main_method();
-      if (main == NULL) {
+      intptr_t main = program_->main_method();
+      if (main == -1) {
         return dart::Library::Handle(Z);
       }
 
       // If the builtin library is not set in the object store, then we are
       // bootstrapping and do not need to patch here.
       dart::Library& builtin_library =
           dart::Library::Handle(Z, I->object_store()->builtin_library());
       if (builtin_library.IsNull()) {
         return dart::Library::Handle(Z);
       }
 
-      CanonicalName* main_library = H.EnclosingName(main);
+      intptr_t main_library = H.EnclosingName(main);
       dart::Library& library = LookupLibrary(main_library);
       // Sanity check that we can find the main entrypoint.
       Object& main_obj = Object::Handle(
           Z, library.LookupObjectAllowPrivate(H.DartSymbol("main")));
       ASSERT(!main_obj.IsNull());
 
       Function& to_patch = Function::Handle(
           Z, builtin_library.LookupFunctionAllowPrivate(
                  dart::String::Handle(dart::String::New("_getMainClosure"))));
 
@@ skipping 289 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 = H.EnclosingName(invocation->target());
+      intptr_t annotation_class = H.EnclosingName(invocation->target());
       ASSERT(H.IsClass(annotation_class));
-      intptr_t class_name_index = annotation_class->name();
+      intptr_t class_name_index = H.CanonicalNameString(annotation_class);
       // Just compare by name, do not generate the annotation class.
       if (!H.StringEquals(class_name_index, "ExternalName")) continue;
-      ASSERT(H.IsLibrary(annotation_class->parent()));
-      intptr_t library_name_index = annotation_class->parent()->name();
+      ASSERT(H.IsLibrary(H.CanonicalNameParent(annotation_class)));
+      intptr_t library_name_index =
+          H.CanonicalNameString(H.CanonicalNameParent(annotation_class));
       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 113 matching lines @@
     dart::String& import_uri_string =
         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_string_offsets(H.string_offsets());
     script.set_kernel_string_data(H.string_data());
+    script.set_kernel_canonical_names(H.canonical_names());
     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 193 matching lines @@
     pos++;
   }
   if (is_setter) {
     function.SetParameterTypeAt(pos, AbstractType::dynamic_type());
     function.SetParameterNameAt(pos, Symbols::Value());
     pos++;
   }
 }
 
 
-dart::Library& KernelReader::LookupLibrary(CanonicalName* library) {
+dart::Library& KernelReader::LookupLibrary(intptr_t library) {
   dart::Library* handle = NULL;
   if (!libraries_.Lookup(library, &handle)) {
-    const dart::String& url = H.DartSymbol(library->name());
+    const dart::String& url = H.DartSymbol(H.CanonicalNameString(library));
     handle =
         &dart::Library::Handle(Z, dart::Library::LookupLibrary(thread_, url));
     if (handle->IsNull()) {
       *handle = dart::Library::New(url);
       handle->Register(thread_);
     }
     ASSERT(!handle->IsNull());
     libraries_.Insert(library, handle);
   }
   return *handle;
 }
 
 
-dart::Class& KernelReader::LookupClass(CanonicalName* klass) {
+dart::Class& KernelReader::LookupClass(intptr_t klass) {
   dart::Class* handle = NULL;
   if (!classes_.Lookup(klass, &handle)) {
-    dart::Library& library = LookupLibrary(klass->parent());
+    dart::Library& library = LookupLibrary(H.CanonicalNameParent(klass));
     const dart::String& name = H.DartClassName(klass);
     handle = &dart::Class::Handle(Z, library.LookupClass(name));
     if (handle->IsNull()) {
       *handle = dart::Class::New(library, name, Script::Handle(Z),
                                  TokenPosition::kNoSource);
       library.AddClass(*handle);
     }
     // Insert the class in the cache before calling ReadPreliminaryClass so
     // we do not risk allocating the class again by calling LookupClass
     // recursively from ReadPreliminaryClass for the same class.
@@ skipping 46 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)