Introduce a lazy-compile stub for functions.

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/cpu.h"
@@ skipping 649 matching lines @@
   }
 
   // Allocate and initialize the empty_descriptors instance.
   {
     uword address = heap->Allocate(PcDescriptors::InstanceSize(0), Heap::kOld);
     InitializeObject(address, kPcDescriptorsCid,
                      PcDescriptors::InstanceSize(0));
     PcDescriptors::initializeHandle(
         empty_descriptors_,
         reinterpret_cast<RawPcDescriptors*>(address + kHeapObjectTag));
-    empty_descriptors_->raw_ptr()->length_ = Smi::New(0);
+    empty_descriptors_->raw_ptr()->length_ = 0;
   }
 
 
   cls = Class::New<Instance>(kDynamicCid);
   cls.set_is_abstract();
   cls.set_num_type_arguments(0);
   cls.set_num_own_type_arguments(0);
   cls.set_is_type_finalized();
   cls.set_is_finalized();
   dynamic_class_ = cls.raw();
@@ skipping 4112 matching lines @@
 void PatchClass::set_source_class(const Class& value) const {
   StorePointer(&raw_ptr()->source_class_, value.raw());
 }
 
 
 bool Function::HasBreakpoint() const {
   return Isolate::Current()->debugger()->HasBreakpoint(*this);
 }
 
 
-void Function::SetCode(const Code& value) const {
+void Function::set_code(const Code& value) const {
   StorePointer(&raw_ptr()->code_, value.raw());
+}
+
+void Function::AttachCode(const Code& value) const {
+  set_code(value);
   ASSERT(Function::Handle(value.function()).IsNull() ||
     (value.function() == this->raw()));
   value.set_owner(*this);
 }
 
 
+bool Function::HasCode() const {
+  ASSERT(raw_ptr()->code_ != Code::null());
+  return raw_ptr()->code_ != StubCode::LazyCompile_entry()->code();
+}
+
+
 void Function::ClearCode() const {
-  StorePointer(&raw_ptr()->code_, Code::null());
+  StorePointer(&raw_ptr()->code_, StubCode::LazyCompile_entry()->code());
   StorePointer(&raw_ptr()->unoptimized_code_, Code::null());
 }
 
 
 void Function::SwitchToUnoptimizedCode() const {
   ASSERT(HasOptimizedCode());
 
   const Code& current_code = Code::Handle(CurrentCode());
 
   // Optimized code object might have been actually fully produced by the
   // intrinsifier in this case nothing has to be done. In fact an attempt to
   // patch such code will cause crash.
   // TODO(vegorov): if intrisifier can fully intrinsify the function then we
   // should not later try to optimize it.
   if (PcDescriptors::Handle(current_code.pc_descriptors()).Length() == 0) {
     return;
   }
 
   if (FLAG_trace_disabling_optimized_code) {
     OS::Print("Disabling optimized code: '%s' entry: %#" Px "\n",
       ToFullyQualifiedCString(),
       current_code.EntryPoint());
   }
   // Patch entry of the optimized code.
   CodePatcher::PatchEntry(current_code);
   // Use previously compiled unoptimized code.
-  SetCode(Code::Handle(unoptimized_code()));
+  AttachCode(Code::Handle(unoptimized_code()));
   CodePatcher::RestoreEntry(Code::Handle(unoptimized_code()));
 }
 
 
 void Function::set_unoptimized_code(const Code& value) const {
   ASSERT(!value.is_optimized());
   StorePointer(&raw_ptr()->unoptimized_code_, value.raw());
 }
 
 
@@ skipping 996 matching lines @@
   result.set_deoptimization_counter(0);
   result.set_optimized_instruction_count(0);
   result.set_optimized_call_site_count(0);
   result.set_is_optimizable(is_native ? false : true);
   result.set_is_inlinable(true);
   result.set_allows_hoisting_check_class(true);
   if (kind == RawFunction::kClosureFunction) {
     const ClosureData& data = ClosureData::Handle(ClosureData::New());
     result.set_data(data);
   }
+  result.set_code(Code::Handle(StubCode::LazyCompile_entry()->code()));
   return result.raw();
 }
 
 
 RawFunction* Function::Clone(const Class& new_owner) const {
   ASSERT(!IsConstructor());
   Function& clone = Function::Handle();
   clone ^= Object::Clone(*this, Heap::kOld);
   const Class& origin = Class::Handle(this->origin());
   const PatchClass& clone_owner =
       PatchClass::Handle(PatchClass::New(new_owner, origin));
   clone.set_owner(clone_owner);
-  clone.StorePointer(&clone.raw_ptr()->code_, Code::null());
-  clone.StorePointer(&clone.raw_ptr()->unoptimized_code_, Code::null());
+  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);
   return clone.raw();
 }
 
 
 RawFunction* Function::NewClosureFunction(const String& name,
                                           const Function& parent,
                                           intptr_t token_pos) {
   ASSERT(!parent.IsNull());
   // Use the owner defining the parent function and not the class containing it.
   const Object& parent_owner = Object::Handle(parent.raw_ptr()->owner_);
   ASSERT(!parent_owner.IsNull());
   const Function& result = Function::Handle(
       Function::New(name,
                     RawFunction::kClosureFunction,
                     /* is_static = */ parent.is_static(),
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     parent.is_native(),
                     parent_owner,
                     token_pos));
   result.set_parent_function(parent);
+
   return result.raw();
 }
 
 
 RawFunction* Function::ImplicitClosureFunction() const {
   // Return the existing implicit closure function if any.
   if (implicit_closure_function() != Function::null()) {
     return implicit_closure_function();
   }
   ASSERT(!IsSignatureFunction() && !IsClosureFunction());
@@ skipping 3885 matching lines @@
   return "Instructions";
 }
 
 
 void Instructions::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Object::PrintToJSONStream(stream, ref);
 }
 
 
 intptr_t PcDescriptors::Length() const {
-  return Smi::Value(raw_ptr()->length_);
+  return raw_ptr()->length_;
 }
 
 
 void PcDescriptors::SetLength(intptr_t value) const {
-  // This is only safe because we create a new Smi, which does not cause
-  // heap allocation.
-  raw_ptr()->length_ = Smi::New(value);
+  raw_ptr()->length_ = value;
 }
 
 
 uword PcDescriptors::PC(intptr_t index) const {
   return static_cast<uword>(*(EntryAddr(index, kPcEntry)));
 }
 
 
 void PcDescriptors::SetPC(intptr_t index, uword value) const {
   *(EntryAddr(index, kPcEntry)) = static_cast<intptr_t>(value);
@@ skipping 181 matching lines @@
 uword PcDescriptors::GetPcForKind(Kind kind) const {
   for (intptr_t i = 0; i < Length(); i++) {
     if (DescriptorKind(i) == kind) {
       return PC(i);
     }
   }
   return 0;
 }
 
 
-void Stackmap::SetCode(const dart::Code& code) const {
-  StorePointer(&raw_ptr()->code_, code.raw());
-}
-
-
 bool Stackmap::GetBit(intptr_t bit_index) const {
   ASSERT(InRange(bit_index));
   int byte_index = bit_index >> kBitsPerByteLog2;
   int bit_remainder = bit_index & (kBitsPerByte - 1);
   uint8_t byte_mask = 1U << bit_remainder;
   uint8_t byte = raw_ptr()->data_[byte_index];
   return (byte & byte_mask);
 }
 
 
@@ skipping 8198 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart