Add a function's initial stack check to the IL instruction stream.

runtime/vm/flow_graph_compiler_x64.cc

 // Copyright (c) 2012, 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"
@@ skipping 628 matching lines @@
   frame_register_allocator()->AllocateRegisters(instr);
 
   // TODO(vegorov): adjust assertion when we start removing comparison from the
   // graph when it is merged with a branch.
   ASSERT(locs->is_call() ||
          (locs->input_count() == instr->InputCount()));
 }
 
 
 void FlowGraphCompiler::CopyParameters() {
+  __ Comment("Copy parameters");
   const Function& function = parsed_function().function();
   const bool is_native_instance_closure =
       function.is_native() && function.IsImplicitInstanceClosureFunction();
   LocalScope* scope = parsed_function().node_sequence()->scope();
   const int num_fixed_params = function.num_fixed_parameters();
   const int num_opt_params = function.num_optional_parameters();
   int implicit_this_param_pos = is_native_instance_closure ? -1 : 0;
   ASSERT(parsed_function().first_parameter_index() ==
          ParsedFunction::kFirstLocalSlotIndex + implicit_this_param_pos);
   // Copy positional arguments.
@@ skipping 258 matching lines @@
     __ int3();
     __ jmp(&StubCode::FixCallersTargetLabel());
     return;
   }
   // Specialized version of entry code from CodeGenerator::GenerateEntryCode.
   const Function& function = parsed_function().function();
 
   const int parameter_count = function.num_fixed_parameters();
   const int num_copied_params = parsed_function().copied_parameter_count();
   const int local_count = parsed_function().stack_local_count();
+  __ Comment("Enter frame");
   if (IsLeaf()) {
     AssemblerMacros::EnterDartLeafFrame(assembler(), (StackSize() * kWordSize));
   } else {
     AssemblerMacros::EnterDartFrame(assembler(), (StackSize() * kWordSize));
   }
   // We check the number of passed arguments when we have to copy them due to
   // the presence of optional named parameters.
   // No such checking code is generated if only fixed parameters are declared,
   // unless we are debug mode or unless we are compiling a closure.
   if (num_copied_params == 0) {
 #ifdef DEBUG
     const bool check_arguments = true;
 #else
     const bool check_arguments = function.IsClosureFunction();
 #endif
     if (check_arguments) {
+      __ Comment("Check argument count");
       // Check that num_fixed <= argc <= num_params.
       Label argc_in_range;
       // Total number of args is the first Smi in args descriptor array (R10).
       __ movq(RAX, FieldAddress(R10, Array::data_offset()));
       __ cmpq(RAX, Immediate(Smi::RawValue(parameter_count)));
       __ j(EQUAL, &argc_in_range, Assembler::kNearJump);
       if (function.IsClosureFunction()) {
         GenerateCallRuntime(Isolate::kNoDeoptId,
                             function.token_pos(),
                             CatchClauseNode::kInvalidTryIndex,
@@ skipping 10 matching lines @@
   // TODO(vegorov): introduce stack maps and stop initializing all spill slots
   // with null.
   const intptr_t stack_slot_count =
       is_ssa_ ? block_order_[0]->AsGraphEntry()->spill_slot_count()
               : local_count;
 
   const intptr_t slot_base = parsed_function().first_stack_local_index();
 
   // Initialize (non-argument) stack allocated locals to null.
   if (stack_slot_count > 0) {
+    __ Comment("Initialize spill slots");
     const Immediate raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     __ movq(RAX, raw_null);
     for (intptr_t i = 0; i < stack_slot_count; ++i) {
       // Subtract index i (locals lie at lower addresses than RBP).
       __ movq(Address(RBP, (slot_base - i) * kWordSize), RAX);
     }
   }
 
-  if (!IsLeaf()) {
-    // Generate stack overflow check.
-    __ movq(RDI, Immediate(Isolate::Current()->stack_limit_address()));
-    __ cmpq(RSP, Address(RDI, 0));
-    Label no_stack_overflow;
-    __ j(ABOVE, &no_stack_overflow, Assembler::kNearJump);
-    GenerateCallRuntime(Isolate::kNoDeoptId,
-                        function.token_pos(),
-                        CatchClauseNode::kInvalidTryIndex,
-                        kStackOverflowRuntimeEntry);
-    __ Bind(&no_stack_overflow);
-  }
   if (FLAG_print_scopes) {
     // Print the function scope (again) after generating the prologue in order
     // to see annotations such as allocation indices of locals.
     if (FLAG_print_ast) {
       // Second printing.
       OS::Print("Annotated ");
     }
     AstPrinter::PrintFunctionScope(parsed_function());
   }
 
@@ skipping 217 matching lines @@
 void ParallelMoveResolver::Exchange(const Address& mem1, const Address& mem2) {
   __ Exchange(mem1, mem2);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64