Initial implementation of on-stack replacement (OSR).

runtime/vm/flow_graph_compiler_x64.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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #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 @@
   __ StoreIntoObject(RAX, FieldAddress(RAX, offset), RBX);
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ movq(RAX, raw_null);
   __ ret();
 }
 
 
 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 = RDI;
-    if (can_optimize) {
-      __ LoadObject(function_reg, function);
-    }
+    __ LoadObject(function_reg, function);
     // 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
+    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()) {
-        __ incq(FieldAddress(function_reg, Function::usage_counter_offset()));
-      }
       __ cmpq(FieldAddress(function_reg, Function::usage_counter_offset()),
-          Immediate(FLAG_optimization_counter_threshold));
-      ASSERT(function_reg == RDI);
-      __ j(GREATER_EQUAL, &StubCode::OptimizeFunctionLabel());
+              Immediate(FLAG_reoptimization_counter_threshold));
+    } else {
+      __ incq(FieldAddress(function_reg, Function::usage_counter_offset()));
+      __ cmpq(FieldAddress(function_reg, Function::usage_counter_offset()),
+              Immediate(FLAG_optimization_counter_threshold));
     }
-  } else {
+    ASSERT(function_reg == RDI);
+    __ j(GREATER_EQUAL, &StubCode::OptimizeFunctionLabel());
+  } else if (!flow_graph().IsCompiledForOsr()) {
     AddCurrentDescriptor(PcDescriptors::kEntryPatch,
-                     Isolate::kNoDeoptId,
-                     0);  // No token position.
+                         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);
+  }
 }
 
 
 void FlowGraphCompiler::CompileGraph() {
   InitCompiler();
   if (TryIntrinsify()) {
     // Although this intrinsified code will never be patched, it must satisfy
     // CodePatcher::CodeIsPatchable, which verifies that this code has a minimum
     // code size, and nop(2) increases the minimum code size appropriately.
     __ nop(2);
@@ skipping 12 matching lines @@
 
   // 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.
   LocalVariable* saved_args_desc_var =
       parsed_function().GetSavedArgumentsDescriptorVar();
   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();
+    const bool check_arguments =
+        function.IsClosureFunction() && !flow_graph().IsCompiledForOsr();
 #endif
     if (check_arguments) {
       __ Comment("Check argument count");
       // Check that exactly num_fixed arguments are passed in.
       Label correct_num_arguments, wrong_num_arguments;
       __ movq(RAX, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
       __ cmpq(RAX, Immediate(Smi::RawValue(num_fixed_params)));
       __ j(NOT_EQUAL, &wrong_num_arguments, Assembler::kNearJump);
       __ cmpq(RAX,
               FieldAddress(R10,
@@ skipping 37 matching lines @@
         __ LeaveFrame();
         __ ret();
       } else {
         __ Stop("Wrong number of arguments");
       }
       __ Bind(&correct_num_arguments);
     }
     // The arguments descriptor is never saved in the absence of optional
     // parameters, since any argument definition test would always yield true.
     ASSERT(saved_args_desc_var == NULL);
-  } else {
+  } else if (!flow_graph().IsCompiledForOsr()) {
     if (saved_args_desc_var != NULL) {
       __ Comment("Save arguments descriptor");
       const Register kArgumentsDescriptorReg = R10;
       // The saved_args_desc_var is allocated one slot before the first local.
       const intptr_t slot = parsed_function().first_stack_local_index() + 1;
       // If the saved_args_desc_var is captured, it is first moved to the stack
       // and later to the context, once the context is allocated.
       ASSERT(saved_args_desc_var->is_captured() ||
              (saved_args_desc_var->index() == slot));
       __ movq(Address(RBP, slot * kWordSize), kArgumentsDescriptorReg);
@@ skipping 688 matching lines @@
   __ movups(reg, Address(RSP, 0));
   __ addq(RSP, Immediate(kFpuRegisterSize));
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64