[turbofan] Enable tail calls for %_CallFunction.

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/code-stubs.h"
 #include "src/compiler.h"
+#include "src/compiler/common-operator.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/node.h"
 #include "src/compiler/pipeline.h"
 #include "src/scopes.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 
@@ skipping 24 matching lines @@
 bool CallDescriptor::HasSameReturnLocationsAs(
     const CallDescriptor* other) const {
   if (ReturnCount() != other->ReturnCount()) return false;
   for (size_t i = 0; i < ReturnCount(); ++i) {
     if (GetReturnLocation(i) != other->GetReturnLocation(i)) return false;
   }
   return true;
 }
 
 
+bool CallDescriptor::CanTailCall(const Node* node) const {
+  // Tail calling is currently allowed if return locations match and all
+  // parameters are either in registers or on the stack but match exactly in
+  // number and content.
+  CallDescriptor const* other = OpParameter<CallDescriptor const*>(node);
+  if (!HasSameReturnLocationsAs(other)) return false;
+  size_t current_input = 0;
+  size_t other_input = 0;
+  size_t stack_parameter = 0;
+  while (true) {
+    if (other_input >= other->InputCount()) {
+      while (current_input <= InputCount()) {
+        if (!GetInputLocation(current_input).is_register()) {
+          return false;
+        }
+        ++current_input;
+      }
+      return true;
+    }
+    if (current_input >= InputCount()) {
+      while (other_input < other->InputCount()) {
+        if (!other->GetInputLocation(other_input).is_register()) {
+          return false;
+        }
+        ++other_input;
+      }
+      return true;
+    }
+    if (GetInputLocation(current_input).is_register()) {
+      ++current_input;
+      continue;
+    }
+    if (other->GetInputLocation(other_input).is_register()) {
+      ++other_input;
+      continue;
+    }
+    if (GetInputLocation(current_input) !=
+        other->GetInputLocation(other_input)) {
+      return false;
+    }
+    Node* input = node->InputAt(static_cast<int>(other_input));
+    if (input->opcode() != IrOpcode::kParameter) {
+      return false;
+    }
+    size_t param_index = ParameterIndexOf(input->op());
+    if (param_index != stack_parameter) {
+      return false;
+    }
+    ++stack_parameter;
+    ++current_input;
+    ++other_input;
+  }
+  UNREACHABLE();
+  return false;
+}
+
+
 CallDescriptor* Linkage::ComputeIncoming(Zone* zone, CompilationInfo* info) {
   if (info->code_stub() != NULL) {
     // Use the code stub interface descriptor.
     CodeStub* stub = info->code_stub();
     CallInterfaceDescriptor descriptor = stub->GetCallInterfaceDescriptor();
     return GetStubCallDescriptor(
         info->isolate(), zone, descriptor, stub->GetStackParameterCount(),
         CallDescriptor::kNoFlags, Operator::kNoProperties);
   }
   if (info->function() != NULL) {
@@ skipping 139 matching lines @@
 
 CallDescriptor* Linkage::GetSimplifiedCDescriptor(Zone* zone,
                                                   const MachineSignature* sig) {
   UNIMPLEMENTED();
   return NULL;
 }
 #endif  // !V8_TURBOFAN_BACKEND
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8