Recognize leaf functions: skip stack check and populating the pc slot, store the pc slot lazily in …

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 15 matching lines @@
 void DeoptimizationStub::GenerateCode(FlowGraphCompiler* compiler) {
   Assembler* assem = compiler->assembler();
 #define __ assem->
   __ Comment("Deopt stub for id %d", deopt_id_);
   __ Bind(entry_label());
   for (intptr_t i = 0; i < registers_.length(); i++) {
     if (registers_[i] != kNoRegister) {
       __ pushq(registers_[i]);
     }
   }
+  if (compiler->IsLeaf()) {
+    Label L;
+    __ call(&L);
+    const intptr_t offset = assem->CodeSize();
+    __ Bind(&L);
+    __ popq(RAX);
+    __ subq(RAX,
+        Immediate(offset - AssemblerMacros::kOffsetOfSavedPCfromEntrypoint));
+    __ movq(Address(RBP, -kWordSize), RAX);
+  }
   __ movq(RAX, Immediate(Smi::RawValue(reason_)));
   __ call(&StubCode::DeoptimizeLabel());
   compiler->AddCurrentDescriptor(PcDescriptors::kOther,
                                  deopt_id_,
                                  deopt_token_pos_,
                                  try_index_);
 #undef __
 }
 
 
@@ skipping 712 matching lines @@
     // The NoSuchMethodFunction stub does not expect to see that area on the
     // stack.
     __ addq(RSP, Immediate(StackSize() * kWordSize));
   }
   if (function.IsClosureFunction()) {
     GenerateCallRuntime(AstNode::kNoId,
                         0,
                         CatchClauseNode::kInvalidTryIndex,
                         kClosureArgumentMismatchRuntimeEntry);
   } else {
+    ASSERT(!IsLeaf());
     // Invoke noSuchMethod function.
     const int kNumArgsChecked = 1;
     ICData& ic_data = ICData::ZoneHandle();
     ic_data = ICData::New(function,
                           String::Handle(function.name()),
                           AstNode::kNoId,
                           kNumArgsChecked);
     __ LoadObject(RBX, ic_data);
     // RBP - 8 : PC marker, allows easy identification of RawInstruction obj.
     // RBP : points to previous frame pointer.
@@ skipping 100 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();
-  AssemblerMacros::EnterDartFrame(assembler(), (StackSize() * kWordSize));
+  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
@@ skipping 22 matching lines @@
     const Immediate raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     __ movq(RAX, raw_null);
     const int base = parsed_function().first_stack_local_index();
     for (int i = 0; i < local_count; ++i) {
       // Subtract index i (locals lie at lower addresses than RBP).
       __ movq(Address(RBP, (base - i) * kWordSize), RAX);
     }
   }
 
-  // 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(AstNode::kNoId,
-                      function.token_pos(),
-                      CatchClauseNode::kInvalidTryIndex,
-                      kStackOverflowRuntimeEntry);
-  __ Bind(&no_stack_overflow);
-
+  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(AstNode::kNoId,
+                        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());
   }
 
   VisitBlocks();
 
   __ int3();
   GenerateDeferredCode();
   // Emit function patching code. This will be swapped with the first 13 bytes
   // at entry point.
   pc_descriptors_list()->AddDescriptor(PcDescriptors::kPatchCode,
                                        assembler()->CodeSize(),
                                        AstNode::kNoId,
                                        0,
                                        -1);
   __ jmp(&StubCode::FixCallersTargetLabel());
 }
 
 
 void FlowGraphCompiler::GenerateCall(intptr_t token_pos,
                                      intptr_t try_index,
                                      const ExternalLabel* label,
                                      PcDescriptors::Kind kind) {
+  ASSERT(!IsLeaf());
   ASSERT(frame_register_allocator()->IsSpilled());
   __ call(label);
   AddCurrentDescriptor(kind, AstNode::kNoId, token_pos, try_index);
 }
 
 
 void FlowGraphCompiler::GenerateCallRuntime(intptr_t cid,
                                             intptr_t token_pos,
                                             intptr_t try_index,
                                             const RuntimeEntry& entry) {
+  ASSERT(!IsLeaf());
   ASSERT(frame_register_allocator()->IsSpilled());
   __ CallRuntime(entry);
   AddCurrentDescriptor(PcDescriptors::kOther, cid, token_pos, try_index);
 }
 
 
 intptr_t FlowGraphCompiler::EmitInstanceCall(ExternalLabel* target_label,
                                              const ICData& ic_data,
                                              const Array& arguments_descriptor,
                                              intptr_t argument_count) {
+  ASSERT(!IsLeaf());
   __ LoadObject(RBX, ic_data);
   __ LoadObject(R10, arguments_descriptor);
 
   __ call(target_label);
   const intptr_t descr_offset = assembler()->CodeSize();
   __ Drop(argument_count);
   return descr_offset;
 }
 
 
 intptr_t FlowGraphCompiler::EmitStaticCall(const Function& function,
                                            const Array& arguments_descriptor,
                                            intptr_t argument_count) {
+  ASSERT(!IsLeaf());
   __ LoadObject(RBX, function);
   __ LoadObject(R10, arguments_descriptor);
   __ call(&StubCode::CallStaticFunctionLabel());
   const intptr_t descr_offset = assembler()->CodeSize();
   __ Drop(argument_count);
   return descr_offset;
 }
 
 
 // Checks class id of instance against all 'class_ids'. Jump to 'deopt' label
@@ skipping 43 matching lines @@
   __ cvtsi2sd(result, temp);
   __ Bind(&done);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64