Fixes a couple problems with GC of unoptimized code.

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 1323 matching lines @@
     Dart_IsolateInterruptCallback callback = isolate->VmStatsCallback();
     if (callback) {
       (*callback)();
     }
   }
 
   if (FLAG_use_osr && (interrupt_bits == 0)) {
     DartFrameIterator iterator;
     StackFrame* frame = iterator.NextFrame();
     ASSERT(frame != NULL);
-    const Function& function = Function::Handle(frame->LookupDartFunction());
+    const Code& code = Code::ZoneHandle(frame->LookupDartCode());
+    ASSERT(!code.IsNull());
+    const Function& function = Function::Handle(code.function());
     ASSERT(!function.IsNull());
-    if (!CanOptimizeFunction(function, isolate)) return;
+    // Since the code is referenced from the frame and the ZoneHandle,
+    // it cannot have been removed from the function.
+    ASSERT(function.HasCode());
+    if (!CanOptimizeFunction(function, isolate)) {
+      return;
+    }
     intptr_t osr_id =
         Code::Handle(function.unoptimized_code()).GetDeoptIdForOsr(frame->pc());
     if (FLAG_trace_osr) {
       OS::Print("Attempting OSR for %s at id=%" Pd ", count=%" Pd "\n",
                 function.ToFullyQualifiedCString(),
                 osr_id,
                 function.usage_counter());
     }
 
     const Code& original_code = Code::Handle(function.CurrentCode());
+    // Since the code is referenced from the frame and the ZoneHandle,
+    // it cannot have been removed from the function.
+    ASSERT(!original_code.IsNull());
     const Error& error =
         Error::Handle(Compiler::CompileOptimizedFunction(function, osr_id));
-    if (!error.IsNull()) Exceptions::PropagateError(error);
+    if (!error.IsNull()) {
+      Exceptions::PropagateError(error);
+    }
 
     const Code& optimized_code = Code::Handle(function.CurrentCode());
     // The current code will not be changed in the case that the compiler
     // bailed out during OSR compilation.
     if (optimized_code.raw() != original_code.raw()) {
       // The OSR code does not work for calling the function, so restore the
       // unoptimized code.  Patch the stack frame to return into the OSR
       // code.
       uword optimized_entry =
           Instructions::Handle(optimized_code.instructions()).EntryPoint();
@@ skipping 56 matching lines @@
   if (frame->IsEntryFrame()) {
     // Since function's current code is always unpatched, the entry frame always
     // calls to unpatched code.
     UNREACHABLE();
   }
   ASSERT(frame->IsDartFrame());
   const Code& caller_code = Code::Handle(frame->LookupDartCode());
   ASSERT(caller_code.is_optimized());
   const Function& target_function = Function::Handle(
       caller_code.GetStaticCallTargetFunctionAt(frame->pc()));
+  const Code& target_code = Code::Handle(
+      caller_code.GetStaticCallTargetCodeAt(frame->pc()));
+  ASSERT(!target_code.IsNull());
+  // Since there was a reference to the target_code in the caller_code, it is
+  // not possible for the target_function's code to be disconnected.
+  ASSERT(target_function.HasCode());
+  ASSERT(target_function.raw() == target_code.function());
 
-  // Check whether the code object has been detached from the target function.
-  // If it has been detached, reattach it.
-  Code& target_code = Code::Handle();
-  if (target_function.HasCode()) {
-    target_code ^= target_function.CurrentCode();
-    CodePatcher::PatchStaticCallAt(frame->pc(), caller_code,
-                                   target_code.EntryPoint());
-    caller_code.SetStaticCallTargetCodeAt(frame->pc(), target_code);
-  } else {
-    ASSERT(target_function.unoptimized_code() == Code::null());
-    target_code ^= caller_code.GetStaticCallTargetCodeAt(frame->pc());
-    ASSERT(!target_code.IsNull());
-    ASSERT(!target_code.is_optimized());
-    target_function.ReattachCode(target_code);
-  }
+  const Code& current_target_code = Code::Handle(target_function.CurrentCode());
+  CodePatcher::PatchStaticCallAt(frame->pc(), caller_code,
+                                 current_target_code.EntryPoint());
+  caller_code.SetStaticCallTargetCodeAt(frame->pc(), current_target_code);
   if (FLAG_trace_patching) {
     OS::PrintErr("FixCallersTarget: patching from %#" Px " to '%s' %#" Px "\n",
         frame->pc(),
-        Function::Handle(target_code.function()).ToFullyQualifiedCString(),
-        target_code.EntryPoint());
+        target_function.ToFullyQualifiedCString(),
+        current_target_code.EntryPoint());
   }
-  arguments.SetReturn(target_code);
-  ASSERT(target_function.HasCode());
+  arguments.SetReturn(current_target_code);
 }
 
 
 const char* DeoptReasonToText(intptr_t deopt_id) {
   switch (deopt_id) {
 #define DEOPT_REASON_ID_TO_TEXT(name) case kDeopt##name: return #name;
 DEOPT_REASONS(DEOPT_REASON_ID_TO_TEXT)
 #undef DEOPT_REASON_ID_TO_TEXT
     default:
       UNREACHABLE();
       return "";
   }
 }
 
 
 void DeoptimizeAt(const Code& optimized_code, uword pc) {
   ASSERT(optimized_code.is_optimized());
   intptr_t deopt_reason = kDeoptUnknown;
   const DeoptInfo& deopt_info =
       DeoptInfo::Handle(optimized_code.GetDeoptInfoAtPc(pc, &deopt_reason));
   ASSERT(!deopt_info.IsNull());
   const Function& function = Function::Handle(optimized_code.function());
   const Code& unoptimized_code = Code::Handle(function.unoptimized_code());
   ASSERT(!unoptimized_code.IsNull());
-  // The switch to unoptimized code may have already occured.
+  // The switch to unoptimized code may have already occurred.
   if (function.HasOptimizedCode()) {
     function.SwitchToUnoptimizedCode();
   }
   // Patch call site (lazy deoptimization is quite rare, patching it twice
   // is not a performance issue).
   uword lazy_deopt_jump = optimized_code.GetLazyDeoptPc();
   ASSERT(lazy_deopt_jump != 0);
   CodePatcher::InsertCallAt(pc, lazy_deopt_jump);
   // Mark code as dead (do not GC its embedded objects).
   optimized_code.set_is_alive(false);
@@ skipping 205 matching lines @@
 // of the given value.
 //   Arg0: Field object;
 //   Arg1: Value that is being stored.
 DEFINE_RUNTIME_ENTRY(UpdateFieldCid, 2) {
   const Field& field = Field::CheckedHandle(arguments.ArgAt(0));
   const Object& value = Object::Handle(arguments.ArgAt(1));
   field.UpdateGuardedCidAndLength(value);
 }
 
 }  // namespace dart