[turbofan] Inline calls to CPP builtins

src/compiler/linkage.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "src/compiler/linkage.h"

[Jarin, 2016/08/19 09:01:10]

I think you should insert an empty line after this. I am surprise that the
alphabetic order checker has not complained about this.

[jgruber, 2016/08/19 11:17:07]

Done. This was actually an automatic change by git-cl format.

 #include "src/ast/scopes.h"
+#include "src/builtins/builtins-utils.h"
 #include "src/code-stubs.h"
 #include "src/compiler.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/frame.h"
-#include "src/compiler/linkage.h"
 #include "src/compiler/node.h"
 #include "src/compiler/osr.h"
 #include "src/compiler/pipeline.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 namespace {
 
@@ skipping 194 matching lines @@
   for (size_t i = 0; i < ReturnCount(); ++i) {
     if (!GetReturnLocation(i).IsRegister()) return false;
   }
   return true;
 }
 
 
 CallDescriptor* Linkage::GetRuntimeCallDescriptor(
     Zone* zone, Runtime::FunctionId function_id, int js_parameter_count,
     Operator::Properties properties, CallDescriptor::Flags flags) {
+  const Runtime::Function* function = Runtime::FunctionForId(function_id);
+  const int return_count = function->result_size;
+  const char* debug_name = function->name;
+
+  if (!Linkage::NeedsFrameStateInput(function_id)) {
+    flags = static_cast<CallDescriptor::Flags>(
+        flags & ~CallDescriptor::kNeedsFrameState);
+  }
+
+  return GetCEntryStubCallDescriptor(zone, return_count, js_parameter_count,
+                                     debug_name, properties, flags);
+}
+
+CallDescriptor* Linkage::GetCEntryStubCallDescriptor(
+    Zone* zone, int return_count, int js_parameter_count,
+    const char* debug_name, Operator::Properties properties,
+    CallDescriptor::Flags flags) {
   const size_t function_count = 1;
   const size_t num_args_count = 1;
   const size_t context_count = 1;
   const size_t parameter_count = function_count +
                                  static_cast<size_t>(js_parameter_count) +
                                  num_args_count + context_count;
 
-  const Runtime::Function* function = Runtime::FunctionForId(function_id);
-  const size_t return_count = static_cast<size_t>(function->result_size);
-
-  LocationSignature::Builder locations(zone, return_count, parameter_count);
+  LocationSignature::Builder locations(zone, static_cast<size_t>(return_count),
+                                       static_cast<size_t>(parameter_count));
 
   // Add returns.
   if (locations.return_count_ > 0) {
     locations.AddReturn(regloc(kReturnRegister0, MachineType::AnyTagged()));
   }
   if (locations.return_count_ > 1) {
     locations.AddReturn(regloc(kReturnRegister1, MachineType::AnyTagged()));
   }
   if (locations.return_count_ > 2) {
     locations.AddReturn(regloc(kReturnRegister2, MachineType::AnyTagged()));
   }
 
   // All parameters to the runtime call go on the stack.
   for (int i = 0; i < js_parameter_count; i++) {
     locations.AddParam(LinkageLocation::ForCallerFrameSlot(
         i - js_parameter_count, MachineType::AnyTagged()));
   }
   // Add runtime function itself.
   locations.AddParam(
       regloc(kRuntimeCallFunctionRegister, MachineType::Pointer()));
 
   // Add runtime call argument count.
   locations.AddParam(
       regloc(kRuntimeCallArgCountRegister, MachineType::Int32()));
 
   // Add context.
   locations.AddParam(regloc(kContextRegister, MachineType::AnyTagged()));
 
-  if (!Linkage::NeedsFrameStateInput(function_id)) {
-    flags = static_cast<CallDescriptor::Flags>(
-        flags & ~CallDescriptor::kNeedsFrameState);
-  }
-
   // The target for runtime calls is a code object.
   MachineType target_type = MachineType::AnyTagged();
   LinkageLocation target_loc =
       LinkageLocation::ForAnyRegister(MachineType::AnyTagged());
   return new (zone) CallDescriptor(     // --
       CallDescriptor::kCallCodeObject,  // kind
       target_type,                      // target MachineType
       target_loc,                       // target location
       locations.Build(),                // location_sig
       js_parameter_count,               // stack_parameter_count
       properties,                       // properties
       kNoCalleeSaved,                   // callee-saved
       kNoCalleeSaved,                   // callee-saved fp
       flags,                            // flags
-      function->name);                  // debug name
+      debug_name);                      // debug name
 }
 
-
 CallDescriptor* Linkage::GetJSCallDescriptor(Zone* zone, bool is_osr,
                                              int js_parameter_count,
                                              CallDescriptor::Flags flags) {
   const size_t return_count = 1;
   const size_t context_count = 1;
   const size_t new_target_count = 1;
   const size_t num_args_count = 1;
   const size_t parameter_count =
       js_parameter_count + new_target_count + num_args_count + context_count;
 
@@ skipping 215 matching lines @@
     DCHECK(loc == regloc(kContextRegister, MachineType::AnyTagged()));
     return LinkageLocation::ForCalleeFrameSlot(Frame::kContextSlot,
                                                MachineType::AnyTagged());
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8