[kernel] Insert kernel bodies into VM heap

runtime/vm/object.cc

 // Copyright (c) 2012, 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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/become.h"
@@ skipping 2715 matching lines @@
                     owner, TokenPosition::kMethodExtractor));
 
   // Initialize signature: receiver is a single fixed parameter.
   const intptr_t kNumParameters = 1;
   extractor.set_num_fixed_parameters(kNumParameters);
   extractor.SetNumOptionalParameters(0, 0);
   extractor.set_parameter_types(Object::extractor_parameter_types());
   extractor.set_parameter_names(Object::extractor_parameter_names());
   extractor.set_result_type(Object::dynamic_type());
   extractor.set_kernel_offset(kernel_offset());
+  extractor.set_kernel_data(TypedData::Handle(zone, kernel_data()));
 
   extractor.set_extracted_method_closure(closure_function);
   extractor.set_is_debuggable(false);
   extractor.set_is_visible(false);
 
   owner.AddFunction(extractor);
 
   return extractor.raw();
 }
 
@@ skipping 3196 matching lines @@
 }
 
 void Function::SetNumOptionalParameters(intptr_t num_optional_parameters,
                                         bool are_optional_positional) const {
   ASSERT(num_optional_parameters >= 0);
   set_num_optional_parameters(are_optional_positional
                                   ? num_optional_parameters
                                   : -num_optional_parameters);
 }
 
+void Function::set_kernel_data(const TypedData& data) const {
+  StorePointer(&raw_ptr()->kernel_data_, data.raw());
+}
+
 bool Function::IsOptimizable() const {
   if (FLAG_precompiled_mode) {
     return true;
   }
   if (is_native()) {
     // Native methods don't need to be optimized.
     return false;
   }
   const intptr_t function_length = end_token_pos().Pos() - token_pos().Pos();
   if (is_optimizable() && (script() != Script::null()) &&
@@ skipping 672 matching lines @@
   const PatchClass& clone_owner =
       PatchClass::Handle(zone, PatchClass::New(new_owner, origin));
   clone.set_owner(clone_owner);
   clone.ClearICDataArray();
   clone.ClearCode();
   clone.set_usage_counter(0);
   clone.set_deoptimization_counter(0);
   clone.set_optimized_instruction_count(0);
   clone.set_optimized_call_site_count(0);
   clone.set_kernel_offset(kernel_offset());
+  clone.set_kernel_data(TypedData::Handle(zone, kernel_data()));
+
   if (new_owner.NumTypeParameters() > 0) {
     // Adjust uninstantiated types to refer to type parameters of the new owner.
     const TypeArguments& type_params =
         TypeArguments::Handle(zone, type_parameters());
     if (!type_params.IsNull()) {
       const intptr_t num_type_params = type_params.Length();
       const TypeArguments& type_params_clone =
           TypeArguments::Handle(zone, TypeArguments::New(num_type_params));
       TypeParameter& type_param = TypeParameter::Handle(zone);
       for (intptr_t i = 0; i < num_type_params; i++) {
@@ skipping 163 matching lines @@
   param_type = Type::DynamicType();
   closure_function.SetParameterTypeAt(0, param_type);
   closure_function.SetParameterNameAt(0, Symbols::ClosureParameter());
   for (int i = kClosure; i < num_params; i++) {
     param_type = ParameterTypeAt(has_receiver - kClosure + i);
     closure_function.SetParameterTypeAt(i, param_type);
     param_name = ParameterNameAt(has_receiver - kClosure + i);
     closure_function.SetParameterNameAt(i, param_name);
   }
   closure_function.set_kernel_offset(kernel_offset());
+  closure_function.set_kernel_data(TypedData::Handle(zone, kernel_data()));
 
   const Type& signature_type =
       Type::Handle(zone, closure_function.SignatureType());
   if (!signature_type.IsFinalized()) {
     ClassFinalizer::FinalizeType(Class::Handle(zone, Owner()), signature_type);
   }
   set_implicit_closure_function(closure_function);
   ASSERT(closure_function.IsImplicitClosureFunction());
   return closure_function.raw();
 }
@@ skipping 855 matching lines @@
 bool Field::IsSetterName(const String& function_name) {
   return function_name.StartsWith(Symbols::SetterPrefix());
 }
 
 void Field::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   ASSERT(IsOriginal());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
+void Field::set_kernel_data(const TypedData& data) const {
+  StorePointer(&raw_ptr()->kernel_data_, data.raw());
+}
+
 RawObject* Field::RawOwner() const {
   if (IsOriginal()) {
     return raw_ptr()->owner_;
   } else {
     const Field& field = Field::Handle(Original());
     ASSERT(field.IsOriginal());
     ASSERT(!Object::Handle(field.raw_ptr()->owner_).IsField());
     return field.raw_ptr()->owner_;
   }
 }
@@ skipping 1244 matching lines @@
     ASSERT(kind < Token::kNumTokens);
     return Symbols::Token(kind).raw();
   } else {
     ASSERT(obj.IsLiteralToken());  // Must be a literal token.
     const LiteralToken& literal_token = LiteralToken::Cast(obj);
     return literal_token.literal();
   }
 }
 
 bool Script::HasSource() const {
-#if !defined(DART_PRECOMPILED_RUNTIME)
-  return kind() == RawScript::kKernelTag ||
-         raw_ptr()->source_ != String::null();
-#else   // !defined(DART_PRECOMPILED_RUNTIME)
   return raw_ptr()->source_ != String::null();
-#endif  // !defined(DART_PRECOMPILED_RUNTIME)
 }
 
 RawString* Script::Source() const {
   String& source = String::Handle(raw_ptr()->source_);
   if (source.IsNull()) {
     return GenerateSource();
   }
   return raw_ptr()->source_;
 }
 
 RawString* Script::GenerateSource() const {
-#if !defined(DART_PRECOMPILED_RUNTIME)
-  if (kind() == RawScript::kKernelTag) {
-    String& source = String::Handle(raw_ptr()->source_);
-    if (source.IsNull()) {
-      // This is created lazily. Now we need it.
-      set_source(kernel::GetSourceFor(*this));
-    }
-    return raw_ptr()->source_;
-  }
-#endif  // !defined(DART_PRECOMPILED_RUNTIME)
-
   const TokenStream& token_stream = TokenStream::Handle(tokens());
   if (token_stream.IsNull()) {
     ASSERT(Dart::vm_snapshot_kind() == Snapshot::kFullAOT);
     return String::null();
   }
   return token_stream.GenerateSource();
 }
 
 void Script::set_compile_time_constants(const Array& value) const {
   StorePointer(&raw_ptr()->compile_time_constants_, value.raw());
 }
 
-void Script::set_kernel_data(const uint8_t* kernel_data) const {
-  StoreNonPointer(&raw_ptr()->kernel_data_, kernel_data);
-}
-
-void Script::set_kernel_data_size(const intptr_t kernel_data_size) const {
-  StoreNonPointer(&raw_ptr()->kernel_data_size_, kernel_data_size);
-}
-
 void Script::set_kernel_script_index(const intptr_t kernel_script_index) const {
   StoreNonPointer(&raw_ptr()->kernel_script_index_, kernel_script_index);
 }
 
 void Script::set_kernel_string_offsets(const TypedData& offsets) const {
   StorePointer(&raw_ptr()->kernel_string_offsets_, offsets.raw());
 }
 
 void Script::set_kernel_string_data(const TypedData& data) const {
   StorePointer(&raw_ptr()->kernel_string_data_, data.raw());
@@ skipping 182 matching lines @@
   Array& yields = Array::Handle(raw_ptr()->yield_positions_);
   if (yields.IsNull() && kind() == RawScript::kKernelTag) {
     // This is created lazily. Now we need it.
     kernel::CollectTokenPositionsFor(*this);
   }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
   return raw_ptr()->yield_positions_;
 }
 
 RawArray* Script::line_starts() const {
-#if !defined(DART_PRECOMPILED_RUNTIME)
-  const Array& line_starts_array = Array::Handle(raw_ptr()->line_starts_);
-  if (line_starts_array.IsNull() && kind() == RawScript::kKernelTag) {
-    // This is created lazily. Now we need it.
-    set_line_starts(kernel::GetLineStartsFor(*this));
-  }
-#endif  // !defined(DART_PRECOMPILED_RUNTIME)
   return raw_ptr()->line_starts_;
 }
 
 RawArray* Script::debug_positions() const {
 #if !defined(DART_PRECOMPILED_RUNTIME)
   Array& debug_positions_array = Array::Handle(raw_ptr()->debug_positions_);
   if (debug_positions_array.IsNull() && kind() == RawScript::kKernelTag) {
     // This is created lazily. Now we need it.
     kernel::CollectTokenPositionsFor(*this);
   }
@@ skipping 721 matching lines @@
   GrowableHandlePtrArray<const String> pieces(zone, 3);
   pieces.Add(cname);
   pieces.Add(Symbols::At());
   pieces.Add(String::Handle(param.name()));
   return Symbols::FromConcatAll(thread, pieces);
 }
 
 void Library::AddMetadata(const Object& owner,
                           const String& name,
                           TokenPosition token_pos,
-                          intptr_t kernel_offset) const {
+                          intptr_t kernel_offset,
+                          const TypedData* kernel_data) const {
   Thread* thread = Thread::Current();
   ASSERT(thread->IsMutatorThread());
   Zone* zone = thread->zone();
   const String& metaname = String::Handle(zone, Symbols::New(thread, name));
   const Field& field =
       Field::Handle(zone, Field::NewTopLevel(metaname,
                                              false,  // is_final
                                              false,  // is_const
                                              owner, token_pos));
   field.SetFieldType(Object::dynamic_type());
   field.set_is_reflectable(false);
   field.SetStaticValue(Array::empty_array(), true);
   field.set_kernel_offset(kernel_offset);
+  if (kernel_data != NULL) {
+    field.set_kernel_data(*kernel_data);
+  }
   GrowableObjectArray& metadata =
       GrowableObjectArray::Handle(zone, this->metadata());
   metadata.Add(field, Heap::kOld);
 }
 
 void Library::AddClassMetadata(const Class& cls,
                                const Object& tl_owner,
                                TokenPosition token_pos,
-                               intptr_t kernel_offset) const {
+                               intptr_t kernel_offset,
+                               const TypedData* kernel_data) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   // We use the toplevel class as the owner of a class's metadata field because
   // a class's metadata is in scope of the library, not the class.
   AddMetadata(tl_owner,
               String::Handle(zone, MakeClassMetaName(thread, zone, cls)),
-              token_pos, kernel_offset);
+              token_pos, kernel_offset, kernel_data);
 }
 
 void Library::AddFieldMetadata(const Field& field,
                                TokenPosition token_pos,
-                               intptr_t kernel_offset) const {
+                               intptr_t kernel_offset,
+                               const TypedData* kernel_data) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   AddMetadata(Object::Handle(zone, field.RawOwner()),
               String::Handle(zone, MakeFieldMetaName(thread, zone, field)),
-              token_pos, kernel_offset);
+              token_pos, kernel_offset, kernel_data);
 }
 
 void Library::AddFunctionMetadata(const Function& func,
                                   TokenPosition token_pos,
-                                  intptr_t kernel_offset) const {
+                                  intptr_t kernel_offset,
+                                  const TypedData* kernel_data) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   AddMetadata(Object::Handle(zone, func.RawOwner()),
               String::Handle(zone, MakeFunctionMetaName(thread, zone, func)),
-              token_pos, kernel_offset);
+              token_pos, kernel_offset, kernel_data);
 }
 
 void Library::AddTypeParameterMetadata(const TypeParameter& param,
                                        TokenPosition token_pos) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   AddMetadata(
       Class::Handle(zone, param.parameterized_class()),
       String::Handle(zone, MakeTypeParameterMetaName(thread, zone, param)),
       token_pos);
@@ skipping 12524 matching lines @@
   }
   return UserTag::null();
 }
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart