Disconnects code objects from infrequently used unoptimized functions.

runtime/vm/flow_graph_compiler_mips.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/globals.h"  // Needed here to get TARGET_ARCH_MIPS.
 #if defined(TARGET_ARCH_MIPS)
 
 #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"
 #include "vm/locations.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
@@ skipping 1098 matching lines @@
   if (flow_graph().IsCompiledForOsr()) {
     intptr_t extra_slots = StackSize()
         - flow_graph().num_stack_locals()
         - flow_graph().num_copied_params();
     ASSERT(extra_slots >= 0);
     __ EnterOsrFrame(extra_slots * kWordSize);
   } else {
     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 = T0;
+    __ LoadObject(function_reg, function);
+    __ lw(T1, FieldAddress(function_reg, Function::code_offset()));
+    __ BranchNotEqual(T1, reinterpret_cast<intptr_t>(Object::null()),
+                      &is_connected);
+    __ lw(T1, Address(FP, kPcMarkerSlotFromFp * kWordSize));
+    const intptr_t code_pc_dist =
+      Instructions::HeaderSize() - Instructions::code_offset() +
+      Assembler::kEntryPointToPcMarkerOffset;
+    __ lw(T1, Address(T1, -code_pc_dist));
+    __ sw(T1, FieldAddress(function_reg, Function::code_offset()));
+    __ sw(T1, FieldAddress(function_reg, Function::unoptimized_code_offset()));
+    __ Bind(&is_connected);
+  }
 }
 
 
 // Input parameters:
 //   RA: return address.
 //   SP: address of last argument.
 //   FP: caller's frame pointer.
 //   PP: caller's pool pointer.
 //   S5: ic-data.
 //   S4: arguments descriptor array.
@@ skipping 266 matching lines @@
 
   ASSERT(kIllegalCid == 0);
   __ beq(T4, ZR, &call_target_function);
   __ bne(T4, T0, &update);
 
   __ Bind(&call_target_function);
   // Call the target found in the cache.  For a class id match, this is a
   // proper target for the given name and arguments descriptor.  If the
   // illegal class id was found, the target is a cache miss handler that can
   // be invoked as a normal Dart function.
-  __ sll(TMP1, T3, 2);
-  __ addu(TMP1, T2, TMP1);
-  __ lw(T0, FieldAddress(TMP, base + kWordSize));
-  __ lw(T0, FieldAddress(T0, Function::code_offset()));
-  __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
+  __ sll(T1, T3, 2);
+  __ addu(T1, T2, T1);
+  __ lw(T0, FieldAddress(T1, base + kWordSize));
+  __ lw(T1, FieldAddress(T0, Function::code_offset()));
+  if (FLAG_collect_code) {
+    // If we are collecting code, the code object may be null.
+    Label is_compiled;
+    __ BranchNotEqual(T1, reinterpret_cast<int32_t>(Object::null()),
+                      &is_compiled);
+    __ EnterStubFrame();
+    __ addiu(SP, SP, Immediate(-3 * kWordSize));
+    __ sw(S5, Address(SP, 2 * kWordSize));  // Preserve IC data.
+    __ sw(S4, Address(SP, 1 * kWordSize));  // Preserve arg desc.
+    __ sw(T0, Address(SP, 0 * kWordSize));  // Function argument.
+    __ CallRuntime(kCompileFunctionRuntimeEntry, 1);
+    __ lw(T0, Address(SP, 0 * kWordSize));  // Restore function.
+    __ lw(S4, Address(SP, 1 * kWordSize));  // Restore arg desc.
+    __ lw(S5, Address(SP, 2 * kWordSize));  // Restore IC data.
+    __ addiu(SP, SP, Immediate(3 * kWordSize));
+    __ LeaveStubFrame();
+    __ lw(T1, FieldAddress(T0, Function::code_offset()));
+    __ Bind(&is_compiled);
+  }
+  __ lw(T0, FieldAddress(T1, Code::instructions_offset()));
   __ LoadObject(S5, ic_data);
   __ LoadObject(S4, arguments_descriptor);
   __ AddImmediate(T0, Instructions::HeaderSize() - kHeapObjectTag);
   __ jalr(T0);
   AddCurrentDescriptor(PcDescriptors::kOther, Isolate::kNoDeoptId, token_pos);
   RecordSafepoint(locs);
   AddDeoptIndexAtCall(Isolate::ToDeoptAfter(deopt_id), token_pos);
   __ Drop(argument_count);
 }
 
@@ skipping 576 matching lines @@
   __ AddImmediate(SP, kDoubleSize);
 }
 
 
 #undef __
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS