Disconnects code objects from infrequently used unoptimized functions.

runtime/vm/flow_graph_compiler_arm.cc

Index: runtime/vm/flow_graph_compiler_arm.cc
===================================================================
--- runtime/vm/flow_graph_compiler_arm.cc	(revision 28803)
+++ runtime/vm/flow_graph_compiler_arm.cc	(working copy)
@@ -8,6 +8,7 @@
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
+#include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/deopt_instructions.h"
 #include "vm/il_printer.h"
@@ -1086,6 +1087,28 @@
     ASSERT(StackSize() >= 0);
     __ EnterDartFrame(StackSize() * kWordSize);
   }
+
+  // TODO(zra): maybe do this only before we try to optimize?
+  if (FLAG_collect_code) {
+    // If we are collecting code, make sure this function still has a pointer
+    // to the code object.
+    // TODO(zra): Is it cheaper just to write the Function fields with the
+    // code object without doing the test?
+    Label is_connected;
+    const Register function_reg = R6;
+    __ LoadObject(function_reg, function);
+    __ ldr(R0, FieldAddress(function_reg, Function::code_offset()));
+    __ CompareImmediate(R0, reinterpret_cast<intptr_t>(Object::null()));
+    __ b(&is_connected, NE);
+    __ ldr(R1, Address(FP, kPcMarkerSlotFromFp * kWordSize));
+    const intptr_t code_pc_dist =
+      Instructions::HeaderSize() - Instructions::code_offset() +
+      Assembler::kEntryPointToPcMarkerOffset;
+    __ ldr(R1, Address(R1, -code_pc_dist));
+    __ str(R1, FieldAddress(function_reg, Function::code_offset()));
+    __ str(R1, FieldAddress(function_reg, Function::unoptimized_code_offset()));
+    __ Bind(&is_connected);
+  }
 }
 
 
@@ -1368,8 +1391,25 @@
   // be invoked as a normal Dart function.
   __ add(IP, R2, ShifterOperand(R3, LSL, 2));
   __ ldr(R0, FieldAddress(IP, base + kWordSize));
-  __ ldr(R0, FieldAddress(R0, Function::code_offset()));
-  __ ldr(R0, FieldAddress(R0, Code::instructions_offset()));
+  __ ldr(R1, FieldAddress(R0, Function::code_offset()));
+  if (FLAG_collect_code) {
+    // If we are collecting code, the code object may be null.
+    Label is_compiled;
+    __ CompareImmediate(R1, reinterpret_cast<intptr_t>(Object::null()));
+    __ b(&is_compiled, NE);
+    __ EnterStubFrame();
+    // Preserve arg desc. and IC data object.
+    __ PushList((1 << R4) | (1 << R5));
+    __ Push(R0);  // Pass function.
+    __ CallRuntime(kCompileFunctionRuntimeEntry, 1);
+    __ Pop(R0);  // Discard argument.
+    __ PopList((1 << R4) | (1 << R5));  // Restore arg desc. and IC data.
+    __ LeaveStubFrame();
+    // R0: target function.
+    __ ldr(R1, FieldAddress(R0, Function::code_offset()));
+    __ Bind(&is_compiled);
+  }
+  __ ldr(R0, FieldAddress(R1, Code::instructions_offset()));
   __ LoadObject(R5, ic_data);
   __ LoadObject(R4, arguments_descriptor);
   __ AddImmediate(R0, Instructions::HeaderSize() - kHeapObjectTag);