[kernel] Insert kernel bodies into VM 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 137 matching lines @@
   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), reader.buffer() + reader.offset(), end_offset);
-  }
+  TypedData& data =
+      reader.CopyDataToVMHeap(Z, reader.offset(), 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());
   }
@@ skipping 101 matching lines @@
         ClassForScriptAt(toplevel_class, field_helper.source_uri_index_);
     dart::Field& field = dart::Field::Handle(
         Z, dart::Field::NewTopLevel(name, field_helper.IsFinal(),
                                     field_helper.IsConst(), script_class,
                                     field_helper.position_));
     field.set_kernel_offset(field_offset);
     const AbstractType& type = T.BuildType();  // read type.
     field.SetFieldType(type);
     field_helper.SetJustRead(FieldHelper::kType);
     field_helper.ReadUntilExcluding(FieldHelper::kInitializer);
+    intptr_t field_initializer_offset = builder_.ReaderOffset();
     field.set_has_initializer(builder_.PeekTag() == kSomething);
-    GenerateFieldAccessors(toplevel_class, field, &field_helper, field_offset);
     field_helper.ReadUntilExcluding(FieldHelper::kEnd);
+    TypedData& kernel_data = builder_.reader_->CopyDataToVMHeap(
+        Z, field_offset, builder_.ReaderOffset());
+    field.set_kernel_data(kernel_data);
+    {
+      // GenerateFieldAccessors reads (some of) the initializer.
+      AlternativeReadingScope alt(builder_.reader_, field_initializer_offset);
+      GenerateFieldAccessors(toplevel_class, field, &field_helper,
+                             field_offset);
+    }
     if (FLAG_enable_mirrors && field_helper.annotation_count_ > 0) {
-      library.AddFieldMetadata(field, TokenPosition::kNoSource, field_offset);
+      library.AddFieldMetadata(field, TokenPosition::kNoSource, field_offset,
+                               &kernel_data);
     }
     fields_.Add(&field);
     library.AddObject(field, name);
   }
   toplevel_class.AddFields(fields_);
 
   // Load toplevel procedures.
   intptr_t procedure_count = builder_.ReadListLength();  // read list length.
   for (intptr_t i = 0; i < procedure_count; ++i) {
     ReadProcedure(library, toplevel_class, false);
@@ skipping 56 matching lines @@
   // a script to detect test functions that should not be optimized.
   if (klass.script() == Script::null()) {
     class_helper.ReadUntilIncluding(ClassHelper::kSourceUriIndex);
     klass.set_script(ScriptAt(class_helper.source_uri_index_));
   }
   if (klass.token_pos() == TokenPosition::kNoSource) {
     class_helper.ReadUntilIncluding(ClassHelper::kPosition);
     klass.set_token_pos(class_helper.position_);
   }
 
+  class_helper.ReadUntilIncluding(ClassHelper::kAnnotations);
+  intptr_t class_offset_after_annotations = builder_.ReaderOffset();
   class_helper.ReadUntilExcluding(ClassHelper::kTypeParameters);
   intptr_t type_parameter_counts =
       builder_.ReadListLength();  // read type_parameters list length.
 
   ActiveClassScope active_class_scope(&active_class_, &klass);
   if (!klass.is_cycle_free()) {
     ReadPreliminaryClass(&klass, &class_helper, type_parameter_counts);
   } else {
     for (intptr_t i = 0; i < type_parameter_counts; ++i) {
       builder_.SkipStringReference();  // read ith name index.
@@ skipping 36 matching lines @@
           Z,
           dart::Field::New(name, field_helper.IsStatic(),
                            // In the VM all const fields are implicitly final
                            // whereas in Kernel they are not final because they
                            // are not explicitly declared that way.
                            field_helper.IsFinal() || field_helper.IsConst(),
                            field_helper.IsConst(), is_reflectable, script_class,
                            type, field_helper.position_));
       field.set_kernel_offset(field_offset);
       field_helper.ReadUntilExcluding(FieldHelper::kInitializer);
+      intptr_t field_initializer_offset = builder_.ReaderOffset();
       field.set_has_initializer(builder_.PeekTag() == kSomething);
-      GenerateFieldAccessors(klass, field, &field_helper, field_offset);
       field_helper.ReadUntilExcluding(FieldHelper::kEnd);
+      TypedData& kernel_data = builder_.reader_->CopyDataToVMHeap(
+          Z, field_offset, builder_.ReaderOffset());
+      field.set_kernel_data(kernel_data);
+      {
+        // GenerateFieldAccessors reads (some of) the initializer.
+        AlternativeReadingScope alt(builder_.reader_, field_initializer_offset);
+        GenerateFieldAccessors(klass, field, &field_helper, field_offset);
+      }
       if (FLAG_enable_mirrors && field_helper.annotation_count_ > 0) {
-        library.AddFieldMetadata(field, TokenPosition::kNoSource, field_offset);
+        library.AddFieldMetadata(field, TokenPosition::kNoSource, field_offset,
+                                 &kernel_data);
       }
       fields_.Add(&field);
     }
     klass.AddFields(fields_);
     class_helper.SetJustRead(ClassHelper::kFields);
   }
 
   class_helper.ReadUntilExcluding(ClassHelper::kConstructors);
   int constructor_count = builder_.ReadListLength();  // read list length.
   for (intptr_t i = 0; i < constructor_count; ++i) {
@@ skipping 20 matching lines @@
     FunctionNodeHelper function_node_helper(&builder_);
     function_node_helper.ReadUntilExcluding(
         FunctionNodeHelper::kRequiredParameterCount);
     builder_.SetupFunctionParameters(klass, function,
                                      true,   // is_method
                                      false,  // is_closure
                                      &function_node_helper);
     function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kEnd);
     constructor_helper.SetJustRead(ConstructorHelper::kFunction);
     constructor_helper.ReadUntilExcluding(ConstructorHelper::kEnd);
+    TypedData& kernel_data = builder_.reader_->CopyDataToVMHeap(
+        Z, constructor_offset, builder_.ReaderOffset());
+    function.set_kernel_data(kernel_data);
 
     if (FLAG_enable_mirrors && constructor_helper.annotation_count_ > 0) {
       library.AddFunctionMetadata(function, TokenPosition::kNoSource,
-                                  constructor_offset);
+                                  constructor_offset, &kernel_data);
     }
   }
   class_helper.SetJustRead(ClassHelper::kConstructors);
 
   class_helper.ReadUntilExcluding(ClassHelper::kProcedures);
   int procedure_count = builder_.ReadListLength();  // read list length.
   for (intptr_t i = 0; i < procedure_count; ++i) {
     ReadProcedure(library, klass, true);
   }
   class_helper.SetJustRead(ClassHelper::kProcedures);
 
   klass.SetFunctions(Array::Handle(MakeFunctionsArray()));
 
   if (!klass.is_marked_for_parsing()) {
     klass.set_is_marked_for_parsing();
   }
 
   if (FLAG_enable_mirrors && class_helper.annotation_count_ > 0) {
+    TypedData& header_data = builder_.reader_->CopyDataToVMHeap(
+        Z, class_offset, class_offset_after_annotations);
     library.AddClassMetadata(klass, toplevel_class, TokenPosition::kNoSource,
-                             class_offset);
+                             class_offset, &header_data);
   }
 
   class_helper.ReadUntilExcluding(ClassHelper::kEnd);
 
   return klass;
 }
 
 void KernelReader::ReadProcedure(const dart::Library& library,
                                  const dart::Class& owner,
                                  bool in_class) {
@@ skipping 128 matching lines @@
   function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kEnd);
   procedure_helper.SetJustRead(ProcedureHelper::kFunction);
 
   if (!in_class) {
     library.AddObject(function, name);
     ASSERT(!Object::Handle(
                 Z, library.LookupObjectAllowPrivate(
                        H.DartProcedureName(procedure_helper.canonical_name_)))
                 .IsNull());
   }
+
+  procedure_helper.ReadUntilExcluding(ProcedureHelper::kEnd);
+  TypedData& kernel_data = builder_.reader_->CopyDataToVMHeap(
+      Z, procedure_offset, builder_.ReaderOffset());
+  function.set_kernel_data(kernel_data);
+
   if (FLAG_enable_mirrors && annotation_count > 0) {
     library.AddFunctionMetadata(function, TokenPosition::kNoSource,
-                                procedure_offset);
+                                procedure_offset, &kernel_data);
   }
-
-  procedure_helper.ReadUntilExcluding(ProcedureHelper::kEnd);
 }
 
 void KernelReader::ReadAndSetupTypeParameters(
     const Object& set_on,
     intptr_t type_parameter_count,
     const Class& parameterized_class,
     const Function& parameterized_function) {
   ASSERT(type_parameter_count >= 0);
   if (type_parameter_count == 0) {
     return;
@@ skipping 66 matching lines @@
 
 Script& KernelReader::ScriptAt(intptr_t index, StringIndex import_uri) {
   Script& script = Script::ZoneHandle(Z);
   script ^= scripts_.At(index);
   if (script.IsNull()) {
     // Create script with correct uri(s).
     dart::String& uri_string = builder_.SourceTableUriFor(index);
     dart::String& import_uri_string =
         import_uri == -1 ? uri_string : H.DartString(import_uri, Heap::kOld);
     script = Script::New(import_uri_string, uri_string,
-                         String::Handle(String::null()), RawScript::kKernelTag);
-    script.set_kernel_data(program_->kernel_data());
-    script.set_kernel_data_size(program_->kernel_data_size());
+                         builder_.GetSourceFor(index), RawScript::kKernelTag);
     script.set_kernel_script_index(index);
     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);
 
-    script.set_line_starts(Array::Handle(Array::null()));
+    script.set_line_starts(builder_.GetLineStartsFor(index));
     script.set_debug_positions(Array::Handle(Array::null()));
     script.set_yield_positions(Array::Handle(Array::null()));
   }
   return script;
 }
 
 void KernelReader::GenerateFieldAccessors(const dart::Class& klass,
                                           const dart::Field& field,
                                           FieldHelper* field_helper,
                                           intptr_t field_offset) {
@@ skipping 45 matching lines @@
           // that are const (not just final) and they have is_const for
           // non-static
           // fields that are final.
           field_helper->IsStatic() ? field_helper->IsConst()
                                    : field_helper->IsFinal(),
           false,  // is_abstract
           false,  // is_external
           false,  // is_native
           script_class, field_helper->position_));
   functions_.Add(&getter);
+  getter.set_kernel_data(TypedData::Handle(Z, field.kernel_data()));
   getter.set_end_token_pos(field_helper->end_position_);
   getter.set_kernel_offset(field_offset);
   getter.set_result_type(AbstractType::Handle(Z, field.type()));
   getter.set_is_debuggable(false);
   SetupFieldAccessorFunction(klass, getter);
 
   if (!field_helper->IsStatic() && !field_helper->IsFinal()) {
     // Only static fields can be const.
     ASSERT(!field_helper->IsConst());
     const dart::String& setter_name =
         H.DartSetterName(field_helper->canonical_name_);
     Function& setter = Function::ZoneHandle(
         Z, Function::New(setter_name, RawFunction::kImplicitSetter,
                          false,  // is_static
                          false,  // is_const
                          false,  // is_abstract
                          false,  // is_external
                          false,  // is_native
                          script_class, field_helper->position_));
     functions_.Add(&setter);
+    setter.set_kernel_data(TypedData::Handle(Z, field.kernel_data()));
     setter.set_end_token_pos(field_helper->end_position_);
     setter.set_kernel_offset(field_offset);
     setter.set_result_type(Object::void_type());
     setter.set_is_debuggable(false);
     SetupFieldAccessorFunction(klass, setter);
   }
 }
 
 void KernelReader::SetupFieldAccessorFunction(const dart::Class& klass,
                                               const dart::Function& function) {
@@ skipping 77 matching lines @@
 bool KernelReader::FieldHasFunctionLiteralInitializer(const dart::Field& field,
                                                       TokenPosition* start,
                                                       TokenPosition* end) {
   dart::Zone* zone = Thread::Current()->zone();
   const Script& script = Script::Handle(zone, field.Script());
 
   TranslationHelper translation_helper(
       Thread::Current(), script.kernel_string_offsets(),
       script.kernel_string_data(), script.kernel_canonical_names());
 
-  kernel::StreamingFlowGraphBuilder* builder =
-      new kernel::StreamingFlowGraphBuilder(&translation_helper, zone,
-                                            script.kernel_data(),
-                                            script.kernel_data_size());
-
-  kernel::FieldHelper field_helper(builder, field.kernel_offset());
+  StreamingFlowGraphBuilder builder(
+      &translation_helper, zone, field.kernel_offset(),
+      TypedData::Handle(zone, field.kernel_data()));
+  kernel::FieldHelper field_helper(&builder);
   field_helper.ReadUntilExcluding(kernel::FieldHelper::kEnd, true);
-  bool result = field_helper.FieldHasFunctionLiteralInitializer(start, end);
-
-  delete builder;
-  return result;
+  return field_helper.FieldHasFunctionLiteralInitializer(start, end);
 }
 
 ParsedFunction* ParseStaticFieldInitializer(Zone* zone,
                                             const dart::Field& field) {
   Thread* thread = Thread::Current();
 
   dart::String& init_name = dart::String::Handle(zone, field.name());
   init_name = Symbols::FromConcat(thread, Symbols::InitPrefix(), init_name);
 
   // Create a static initializer.
   const Object& owner = Object::Handle(field.RawOwner());
   const Function& initializer_fun = Function::ZoneHandle(
       zone,
       dart::Function::New(init_name, RawFunction::kImplicitStaticFinalGetter,
                           true,   // is_static
                           false,  // is_const
                           false,  // is_abstract
                           false,  // is_external
                           false,  // is_native
                           owner, TokenPosition::kNoSource));
+  initializer_fun.set_kernel_data(TypedData::Handle(zone, field.kernel_data()));
   initializer_fun.set_kernel_offset(field.kernel_offset());
   initializer_fun.set_result_type(AbstractType::Handle(zone, field.type()));
   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)