Fixes a couple problems with GC of unoptimized code.

runtime/vm/deopt_instructions.cc

 // Copyright (c) 2013, 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/deopt_instructions.h"
 
 #include "vm/assembler.h"
 #include "vm/code_patcher.h"
 #include "vm/intermediate_language.h"
 #include "vm/locations.h"
@@ skipping 548 matching lines @@
   }
 
   virtual DeoptInstr::Kind kind() const { return kRetAddress; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "ret oti:%" Pd "(%" Pd ")", object_table_index_, deopt_id_);
   }
 
   void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) {
-    Function& function = Function::Handle(deopt_context->isolate());
-    function ^= deopt_context->ObjectAt(object_table_index_);
-    const Code& code =
-        Code::Handle(deopt_context->isolate(), function.unoptimized_code());
+    Code& code = Code::Handle(deopt_context->isolate());
+    code ^= deopt_context->ObjectAt(object_table_index_);
     ASSERT(!code.IsNull());
     uword continue_at_pc = code.GetPcForDeoptId(deopt_id_,
                                                 PcDescriptors::kDeopt);
     ASSERT(continue_at_pc != 0);
     *dest_addr = continue_at_pc;
 
     uword pc = code.GetPcForDeoptId(deopt_id_, PcDescriptors::kIcCall);
     if (pc != 0) {
       // If the deoptimization happened at an IC call, update the IC data
       // to avoid repeated deoptimization at the same site next time around.
@@ skipping 199 matching lines @@
 
   virtual intptr_t source_index() const { return object_table_index_; }
   virtual DeoptInstr::Kind kind() const { return kPcMarker; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "pcmark oti:%" Pd "", object_table_index_);
   }
 
   void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) {
-    Function& function = Function::Handle(deopt_context->isolate());
-    function ^= deopt_context->ObjectAt(object_table_index_);
-    if (function.IsNull()) {
+    Code& code = Code::Handle(deopt_context->isolate());
+    code ^= deopt_context->ObjectAt(object_table_index_);
+    if (code.IsNull()) {
       // Callee's PC marker is not used (pc of Deoptimize stub). Set to 0.
       *dest_addr = 0;
       return;
     }
-    const Code& code =
-        Code::Handle(deopt_context->isolate(), function.unoptimized_code());
-    ASSERT(!code.IsNull());
+    const Function& function =
+        Function::Handle(deopt_context->isolate(), code.function());
+    if (!function.HasCode()) {

[Ivan Posva, 2013/11/16 00:06:21]

Should be an assert. The unoptimized code cannot be detached while there is a
reference.

[zra, 2013/11/18 18:54:33]

Changed to ASSERT.

+      ASSERT(!code.is_optimized());
+      function.ReattachCode(code);
+    }
     const intptr_t pc_marker =
         code.EntryPoint() + Assembler::kEntryPointToPcMarkerOffset;
     *dest_addr = pc_marker;
     // Increment the deoptimization counter. This effectively increments each
     // function occurring in the optimized frame.
     function.set_deoptimization_counter(function.deoptimization_counter() + 1);
     if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
       OS::PrintErr("Deoptimizing %s (count %d)\n",
           function.ToFullyQualifiedCString(),
           function.deoptimization_counter());
     }
     // Clear invocation counter so that hopefully the function gets reoptimized
     // only after more feedback has been collected.
     function.set_usage_counter(0);
-    if (function.HasOptimizedCode()) function.SwitchToUnoptimizedCode();
+    if (function.HasOptimizedCode()) {
+      function.SwitchToUnoptimizedCode();
+    }
   }
 
  private:
   intptr_t object_table_index_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptPcMarkerInstr);
 };
 
 
 // Deoptimization instruction creating a pool pointer for the code of
 // function at 'object_table_index'.
 class DeoptPpInstr : public DeoptInstr {
  public:
   explicit DeoptPpInstr(intptr_t object_table_index)
       : object_table_index_(object_table_index) {
     ASSERT(object_table_index >= 0);
   }
 
   virtual intptr_t source_index() const { return object_table_index_; }
   virtual DeoptInstr::Kind kind() const { return kPp; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "pp oti:%" Pd "", object_table_index_);
   }
 
   void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) {
-    Function& function = Function::Handle(deopt_context->isolate());
-    function ^= deopt_context->ObjectAt(object_table_index_);
-    const Code& code =
-        Code::Handle(deopt_context->isolate(), function.unoptimized_code());
+    Code& code = Code::Handle(deopt_context->isolate());
+    code ^= deopt_context->ObjectAt(object_table_index_);
     ASSERT(!code.IsNull());
     const intptr_t pp = reinterpret_cast<intptr_t>(code.ObjectPool());
     *dest_addr = pp;
   }
 
  private:
   intptr_t object_table_index_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptPpInstr);
 };
@@ skipping 186 matching lines @@
                                 const Array& object_table,
                                 Function* func) {
   ASSERT(instr->kind() == kRetAddress);
   DeoptRetAddressInstr* ret_address_instr =
       static_cast<DeoptRetAddressInstr*>(instr);
   // The following assert may trigger when displaying a backtrace
   // from the simulator.
   ASSERT(Isolate::IsDeoptAfter(ret_address_instr->deopt_id()));
   ASSERT(!object_table.IsNull());
   ASSERT(func != NULL);
-  *func ^= object_table.At(ret_address_instr->object_table_index());
-  const Code& code = Code::Handle(func->unoptimized_code());
+  Code& code = Code::Handle();
+  code ^= object_table.At(ret_address_instr->object_table_index());
   ASSERT(!code.IsNull());
+  *func ^= code.function();
   uword res = code.GetPcForDeoptId(ret_address_instr->deopt_id(),
                                    PcDescriptors::kDeopt);
   ASSERT(res != 0);
   return res;
 }
 
 
 DeoptInstr* DeoptInstr::Create(intptr_t kind_as_int, intptr_t source_index) {
   Kind kind = static_cast<Kind>(kind_as_int);
   switch (kind) {
@@ skipping 87 matching lines @@
 
 
 intptr_t DeoptInfoBuilder::CalculateStackIndex(
     const Location& source_loc) const {
   return source_loc.stack_index() < 0 ?
             source_loc.stack_index() + num_args_ :
             source_loc.stack_index() + num_args_ + kDartFrameFixedSize;
 }
 
 
-void DeoptInfoBuilder::AddReturnAddress(const Function& function,
+void DeoptInfoBuilder::AddReturnAddress(const Code& code,
                                         intptr_t deopt_id,
                                         intptr_t dest_index) {
   // Check that deopt_id exists.
   // TODO(vegorov): verify after deoptimization targets as well.
 #ifdef DEBUG
-  const Code& code = Code::Handle(function.unoptimized_code());
-  // The inlined function's code pointer may be null if there is a GC during
-  // compilation.
-  // TODO(zra): See if we can avoid this check by ensuring that code is not
-  //            removed during inlining.
-  ASSERT(code.IsNull() || Isolate::IsDeoptAfter(deopt_id) ||
-      (code.GetPcForDeoptId(deopt_id, PcDescriptors::kDeopt) != 0));
+  ASSERT(Isolate::IsDeoptAfter(deopt_id) ||
+         (code.GetPcForDeoptId(deopt_id, PcDescriptors::kDeopt) != 0));
 #endif
-  const intptr_t object_table_index = FindOrAddObjectInTable(function);
+  const intptr_t object_table_index = FindOrAddObjectInTable(code);
   ASSERT(dest_index == FrameSize());
   instructions_.Add(new DeoptRetAddressInstr(object_table_index, deopt_id));
 }
 
 
-void DeoptInfoBuilder::AddPcMarker(const Function& function,
+void DeoptInfoBuilder::AddPcMarker(const Code& code,
                                    intptr_t dest_index) {
-  intptr_t object_table_index = FindOrAddObjectInTable(function);
+  intptr_t object_table_index = FindOrAddObjectInTable(code);
   ASSERT(dest_index == FrameSize());
   instructions_.Add(new DeoptPcMarkerInstr(object_table_index));
 }
 
 
-void DeoptInfoBuilder::AddPp(const Function& function, intptr_t dest_index) {
-  intptr_t object_table_index = FindOrAddObjectInTable(function);
+void DeoptInfoBuilder::AddPp(const Code& code,
+                             intptr_t dest_index) {
+  intptr_t object_table_index = FindOrAddObjectInTable(code);
   ASSERT(dest_index == FrameSize());
   instructions_.Add(new DeoptPpInstr(object_table_index));
 }
 
 
 void DeoptInfoBuilder::AddCopy(Value* value,
                                const Location& source_loc,
                                const intptr_t dest_index) {
   DeoptInstr* deopt_instr = NULL;
   if (source_loc.IsConstant()) {
@@ skipping 207 matching lines @@
                           Smi* offset,
                           DeoptInfo* info,
                           Smi* reason) {
   intptr_t i = index * kEntrySize;
   *offset ^= table.At(i);
   *info ^= table.At(i + 1);
   *reason ^= table.At(i + 2);
 }
 
 }  // namespace dart