Disconnects code objects from infrequently used unoptimized 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 4020 matching lines @@
 
 
 void Function::SetCode(const Code& value) const {
   StorePointer(&raw_ptr()->code_, value.raw());
   ASSERT(Function::Handle(value.function()).IsNull() ||
     (value.function() == this->raw()));
   value.set_function(*this);
 }
 
 
+void Function::DetachCode() const {
+  // Set unoptimized code as non-entrant, and set code and unoptimized code
+  // to null.
+  CodePatcher::PatchEntry(Code::Handle(unoptimized_code()));
+  StorePointer(&raw_ptr()->code_, Code::null());
+  StorePointer(&raw_ptr()->unoptimized_code_, Code::null());
+}
+
+
+void Function::ReattachCode(const Code& code) const {
+  set_unoptimized_code(code);
+  SetCode(code);
+  CodePatcher::RestoreEntry(code);
+}
+
+
 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 intrisify 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()));
   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());
 }
 
 
 RawContextScope* Function::context_scope() const {
   if (IsClosureFunction()) {
     const Object& obj = Object::Handle(raw_ptr()->data_);
     ASSERT(!obj.IsNull());
     return ClosureData::Cast(obj).context_scope();
   }
@@ skipping 5186 matching lines @@
     return Function::null();
   }
   const Array& array =
       Array::Handle(raw_ptr()->static_calls_target_table_);
   Function& function = Function::Handle();
   function ^= array.At(i + kSCallTableFunctionEntry);
   return function.raw();
 }
 
 
+RawCode* Code::GetStaticCallTargetCodeAt(uword pc) const {
+  const intptr_t i = BinarySearchInSCallTable(pc);
+  if (i < 0) {
+    return Code::null();
+  }
+  const Array& array =
+      Array::Handle(raw_ptr()->static_calls_target_table_);
+  Code& code = Code::Handle();
+  code ^= array.At(i + kSCallTableCodeEntry);
+  return code.raw();
+}
+
+
 void Code::SetStaticCallTargetCodeAt(uword pc, const Code& code) const {
   const intptr_t i = BinarySearchInSCallTable(pc);
   ASSERT(i >= 0);
   const Array& array =
       Array::Handle(raw_ptr()->static_calls_target_table_);
   ASSERT(code.IsNull() ||
          (code.function() == array.At(i + kSCallTableFunctionEntry)));
   array.SetAt(i + kSCallTableCodeEntry, code);
 }
 
@@ skipping 6282 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart