Tail call from TurboFan into select runtime calls

src/compiler/linkage-impl.h

 // 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.
 
 #ifndef V8_COMPILER_LINKAGE_IMPL_H_
 #define V8_COMPILER_LINKAGE_IMPL_H_
 
 #include "src/code-stubs.h"
 #include "src/compiler/osr.h"
+#include "src/runtime/runtime.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // TODO(titzer): replace uses of int with size_t in LinkageHelper.
 template <typename LinkageTraits>
 class LinkageHelper {
  public:
   static const RegList kNoCalleeSaved = 0;
@@ skipping 92 matching lines @@
     locations.AddParam(regloc(LinkageTraits::RuntimeCallArgCountReg()));
     types.AddParam(kMachPtr);
 
     // Add context.
     locations.AddParam(regloc(LinkageTraits::ContextReg()));
     types.AddParam(kMachAnyTagged);
 
     CallDescriptor::Flags flags = Linkage::FrameStateInputCount(function_id) > 0
                                       ? CallDescriptor::kNeedsFrameState
                                       : CallDescriptor::kNoFlags;
+    if (Runtime::SupportsTailCall(function_id)) {

[Michael Starzinger, 2015/08/04 15:01:54]

This new predicate on {Runtime} is similar to Linkage::FrameStateInputCount. Can
we move it to {Linkage} into the linkage.cc file for consistency? I agree that
this decouples it from the list of runtime functions (which might be
controversial), but we already went with that for the frame states, and I would
rather keep it consistent. WDYT?

+      flags |= CallDescriptor::kSupportsTailCalls;
+    }
 
     // The target for runtime calls is a code object.
     MachineType target_type = kMachAnyTagged;
     LinkageLocation target_loc = LinkageLocation::AnyRegister();
     return new (zone) CallDescriptor(     // --
         CallDescriptor::kCallCodeObject,  // kind
         target_type,                      // target MachineType
         target_loc,                       // target location
         types.Build(),                    // machine_sig
         locations.Build(),                // location_sig
@@ skipping 190 matching lines @@
     int parameter_index = 1 + index;  // skip index 0, which is the target.
     return incoming_->GetInputLocation(parameter_index);
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_LINKAGE_IMPL_H_