Implements OSR for arm and mips.

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 "lib/error.h"
 #include "vm/ast_printer.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"
 
 namespace dart {
 
 DEFINE_FLAG(bool, trap_on_deoptimization, false, "Trap on deoptimization.");
 DECLARE_FLAG(int, optimization_counter_threshold);
+DECLARE_FLAG(int, reoptimization_counter_threshold);
 DECLARE_FLAG(bool, print_ast);
 DECLARE_FLAG(bool, print_scopes);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, eliminate_type_checks);
 
 
 FlowGraphCompiler::~FlowGraphCompiler() {
   // BlockInfos are zone-allocated, so their destructors are not called.
   // Verify the labels explicitly here.
   for (int i = 0; i < block_info_.length(); ++i) {
@@ skipping 1028 matching lines @@
   __ lw(T1, Address(SP, 0 * kWordSize));  // Value.
   __ StoreIntoObject(T0, FieldAddress(T0, offset), T1);
   __ LoadImmediate(TMP, reinterpret_cast<int32_t>(Object::null()));
   __ Ret();
   __ delay_slot()->mov(V0, TMP);
 }
 
 
 void FlowGraphCompiler::EmitFrameEntry() {
   const Function& function = parsed_function().function();
-  if (CanOptimizeFunction() && function.is_optimizable()) {
-    const bool can_optimize = !is_optimizing() || may_reoptimize();
+  if (CanOptimizeFunction() &&
+      function.is_optimizable() &&
+      (!is_optimizing() || may_reoptimize())) {
     const Register function_reg = T0;
-    if (can_optimize) {
-      Label next;
-      // The pool pointer is not setup before entering the Dart frame.
 
-      __ mov(TMP1, RA);  // Save RA.
-      __ bal(&next);  // Branch and link to next instruction to get PC in RA.
-      __ delay_slot()->mov(T2, RA);  // Save PC of the following mov.
+    Label next;
+    // The pool pointer is not setup before entering the Dart frame.
+    __ mov(TMP1, RA);  // Save RA.
+    __ bal(&next);  // Branch and link to next instruction to get PC in RA.
+    __ delay_slot()->mov(T2, RA);  // Save PC of the following mov.
+    // Calculate offset of pool pointer from the PC.
+    const intptr_t object_pool_pc_dist =
+       Instructions::HeaderSize() - Instructions::object_pool_offset() +
+       assembler()->CodeSize();
+    __ Bind(&next);
+    __ mov(RA, TMP1);  // Restore RA.
+    // Preserve PP of caller.
+    __ mov(T1, PP);
+    // Temporarily setup pool pointer for this dart function.
+    __ lw(PP, Address(T2, -object_pool_pc_dist));
+    // Load function object from object pool.
+    __ LoadObject(function_reg, function);  // Uses PP.
+    // Restore PP of caller.
+    __ mov(PP, T1);
 
-      // Calculate offset of pool pointer from the PC.
-      const intptr_t object_pool_pc_dist =
-         Instructions::HeaderSize() - Instructions::object_pool_offset() +
-         assembler()->CodeSize();
-
-      __ Bind(&next);
-      __ mov(RA, TMP1);  // Restore RA.
-
-      // Preserve PP of caller.
-      __ mov(T1, PP);
-
-      // Temporarily setup pool pointer for this dart function.
-      __ lw(PP, Address(T2, -object_pool_pc_dist));
-
-      // Load function object from object pool.
-      __ LoadObject(function_reg, function);  // Uses PP.
-
-      // Restore PP of caller.
-      __ mov(PP, T1);
-    }
     // Patch point is after the eventually inlined function object.
     AddCurrentDescriptor(PcDescriptors::kEntryPatch,
                          Isolate::kNoDeoptId,
                          0);  // No token position.
-    if (can_optimize) {
-      // Reoptimization of optimized function is triggered by counting in
+    intptr_t threshold = FLAG_optimization_counter_threshold;
+    __ lw(T1, FieldAddress(function_reg, Function::usage_counter_offset()));
+    if (is_optimizing()) {
+      // Reoptimization of an optimized function is triggered by counting in
       // IC stubs, but not at the entry of the function.
-      if (!is_optimizing()) {
-        __ lw(T1, FieldAddress(function_reg,
-                               Function::usage_counter_offset()));
-        __ addiu(T1, T1, Immediate(1));
-        __ sw(T1, FieldAddress(function_reg,
-                               Function::usage_counter_offset()));
-      } else {
-        __ lw(T1, FieldAddress(function_reg,
-                               Function::usage_counter_offset()));
-      }
+      threshold = FLAG_reoptimization_counter_threshold;
+    } else {
+      __ addiu(T1, T1, Immediate(1));
+      __ sw(T1, FieldAddress(function_reg, Function::usage_counter_offset()));
+    }
 
-      // Skip Branch if T1 is less than the threshold.
-      Label dont_branch;
-      __ BranchSignedLess(T1, FLAG_optimization_counter_threshold,
-                          &dont_branch);
+    // Skip Branch if T1 is less than the threshold.
+    Label dont_branch;
+    __ BranchSignedLess(T1, threshold, &dont_branch);
 
-      ASSERT(function_reg == T0);
-      __ Branch(&StubCode::OptimizeFunctionLabel());
+    ASSERT(function_reg == T0);
+    __ Branch(&StubCode::OptimizeFunctionLabel());
 
-      __ Bind(&dont_branch);
-    }
-  } else {
+    __ Bind(&dont_branch);
+
+  } else if (!flow_graph().IsCompiledForOsr()) {
     AddCurrentDescriptor(PcDescriptors::kEntryPatch,
                          Isolate::kNoDeoptId,
                          0);  // No token position.
   }
   __ Comment("Enter frame");
-  __ EnterDartFrame(StackSize() * kWordSize);
+  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);
+  }
 }
 
 
 // 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 16 matching lines @@
   const int num_copied_params = parsed_function().num_copied_params();
   const int num_locals = parsed_function().num_stack_locals();
 
   // We check the number of passed arguments when we have to copy them due to
   // the presence of optional parameters.
   // No such checking code is generated if only fixed parameters are declared,
   // unless we are in debug mode or unless we are compiling a closure.
   if (num_copied_params == 0) {
 #ifdef DEBUG
     ASSERT(!parsed_function().function().HasOptionalParameters());
-    const bool check_arguments = true;
+    const bool check_arguments = !flow_graph().IsCompiledForOsr();
 #else
     const bool check_arguments =
-        function.IsClosureFunction() || function.IsNoSuchMethodDispatcher();
+        (function.IsClosureFunction() || function.IsNoSuchMethodDispatcher()) &&
+        !flow_graph().IsCompiledForOsr();
 #endif
     if (check_arguments) {
       __ TraceSimMsg("Check argument count");
       __ Comment("Check argument count");
       // Check that exactly num_fixed arguments are passed in.
       Label correct_num_arguments, wrong_num_arguments;
       __ lw(T0, FieldAddress(S4, ArgumentsDescriptor::count_offset()));
       __ BranchNotEqual(T0, Smi::RawValue(num_fixed_params),
                         &wrong_num_arguments);
 
@@ skipping 15 matching lines @@
         __ LoadObject(S5, ic_data);
         __ LeaveDartFrame();  // The arguments are still on the stack.
         __ Branch(&StubCode::CallNoSuchMethodFunctionLabel());
         // The noSuchMethod call may return to the caller, but not here.
         __ break_(0);
       } else {
         __ Stop("Wrong number of arguments");
       }
       __ Bind(&correct_num_arguments);
     }
-  } else {
+  } else if (!flow_graph().IsCompiledForOsr()) {
     CopyParameters();
   }
 
   // In unoptimized code, initialize (non-argument) stack allocated slots to
   // null.
   if (!is_optimizing() && (num_locals > 0)) {
     __ TraceSimMsg("Initialize spill slots");
     __ Comment("Initialize spill slots");
     const intptr_t slot_base = parsed_function().first_stack_local_index();
     for (intptr_t i = 0; i < num_locals; ++i) {
@@ skipping 771 matching lines @@
   __ AddImmediate(SP, kDoubleSize);
 }
 
 
 #undef __
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS