[turbofan] Fix tail call optimization.

src/compiler/instruction-selector.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/instruction-selector.h"
 
 #include <limits>
 
 #include "src/base/adapters.h"
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
-#include "src/compiler/node-properties.h"
 #include "src/compiler/pipeline.h"
 #include "src/compiler/schedule.h"
 #include "src/compiler/state-values-utils.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 InstructionSelector::InstructionSelector(
     Zone* zone, size_t node_count, Linkage* linkage,
@@ skipping 248 matching lines @@
   instruction_args.reserve(input_count() + frame_state_value_count());
 }
 
 
 // TODO(bmeurer): Get rid of the CallBuffer business and make
 // InstructionSelector::VisitCall platform independent instead.
 void InstructionSelector::InitializeCallBuffer(Node* call, CallBuffer* buffer,
                                                bool call_code_immediate,
                                                bool call_address_immediate) {
   OperandGenerator g(this);
-  DCHECK_EQ(call->op()->ValueOutputCount(),
+  DCHECK_LE(call->op()->ValueOutputCount(),
             static_cast<int>(buffer->descriptor->ReturnCount()));
   DCHECK_EQ(
       call->op()->ValueInputCount(),
       static_cast<int>(buffer->input_count() + buffer->frame_state_count()));
 
   if (buffer->descriptor->ReturnCount() > 0) {
     // Collect the projections that represent multiple outputs from this call.
     if (buffer->descriptor->ReturnCount() == 1) {
       buffer->output_nodes.push_back(call);
     } else {
@@ skipping 165 matching lines @@
 #endif
 
   Node* input = block->control_input();
   switch (block->control()) {
     case BasicBlock::kGoto:
       return VisitGoto(block->SuccessorAt(0));
     case BasicBlock::kCall: {
       DCHECK_EQ(IrOpcode::kCall, input->opcode());
       BasicBlock* success = block->SuccessorAt(0);
       BasicBlock* exception = block->SuccessorAt(1);
-      return VisitCall(input, exception, NORMAL_CALL), VisitGoto(success);
+      return VisitCall(input, exception), VisitGoto(success);
+    }
+    case BasicBlock::kTailCall: {
+      DCHECK_EQ(IrOpcode::kTailCall, input->opcode());
+      return VisitTailCall(input);
     }
     case BasicBlock::kBranch: {
       DCHECK_EQ(IrOpcode::kBranch, input->opcode());
       BasicBlock* tbranch = block->SuccessorAt(0);
       BasicBlock* fbranch = block->SuccessorAt(1);
       if (tbranch == fbranch) return VisitGoto(tbranch);
       // Treat special Branch(Always, IfTrue, IfFalse) as Goto(IfTrue).
       Node* const condition = input->InputAt(0);
       if (condition->opcode() == IrOpcode::kAlways) return VisitGoto(tbranch);
       return VisitBranch(input, tbranch, fbranch);
@@ skipping 22 matching lines @@
       DCHECK_LE(sw.min_value, sw.max_value);
       // Note that {value_range} can be 0 if {min_value} is -2^31 and
       // {max_value}
       // is 2^31-1, so don't assume that it's non-zero below.
       sw.value_range = 1u + bit_cast<uint32_t>(sw.max_value) -
                        bit_cast<uint32_t>(sw.min_value);
       return VisitSwitch(input, sw);
     }
     case BasicBlock::kReturn: {
       DCHECK_EQ(IrOpcode::kReturn, input->opcode());
-      return VisitReturn(input);
+      return VisitReturn(input->InputAt(0));
     }
     case BasicBlock::kDeoptimize: {
       // If the result itself is a return, return its input.
       Node* value =
           (input != nullptr && input->opcode() == IrOpcode::kDeoptimize)
               ? input->InputAt(0)
               : input;
       return VisitDeoptimize(value);
     }
     case BasicBlock::kThrow:
@@ skipping 56 matching lines @@
     case IrOpcode::kFloat64Constant:
       return MarkAsFloat64(node), VisitConstant(node);
     case IrOpcode::kHeapConstant:
       return MarkAsReference(node), VisitConstant(node);
     case IrOpcode::kNumberConstant: {
       double value = OpParameter<double>(node);
       if (!IsSmiDouble(value)) MarkAsReference(node);
       return VisitConstant(node);
     }
     case IrOpcode::kCall:
-      return VisitCall(node, nullptr, NORMAL_CALL);
+      return VisitCall(node);
     case IrOpcode::kFrameState:
     case IrOpcode::kStateValues:
       return;
     case IrOpcode::kLoad: {
       LoadRepresentation rep = OpParameter<LoadRepresentation>(node);
       MarkAsRepresentation(rep, node);
       return VisitLoad(node);
     }
     case IrOpcode::kStore:
       return VisitStore(node);
@@ skipping 384 matching lines @@
 }
 
 
 void InstructionSelector::VisitGoto(BasicBlock* target) {
   // jump to the next block.
   OperandGenerator g(this);
   Emit(kArchJmp, g.NoOutput(), g.Label(target));
 }
 
 
-namespace {
-
-// Returns the call node if the given return node is part of a tail call,
-// nullptr otherwise.
-Node* TryMatchTailCall(Node* ret) {
-  // The value which is returned must be the result of a potential tail call,
-  // there must be no try/catch/finally around the call, and there must be no
-  // effects between the call and the return.
-  Node* call = NodeProperties::GetValueInput(ret, 0);
-  if (call->opcode() != IrOpcode::kCall ||
-      !OpParameter<const CallDescriptor*>(call)->SupportsTailCalls() ||
-      NodeProperties::IsExceptionalCall(call) ||
-      NodeProperties::GetEffectInput(ret, 0) != call) {
-    return nullptr;
-  }
-  // Furthermore, control has to flow via an IfSuccess from the call (for calls
-  // which can throw), or the return and the call have to use the same control
-  // input (for calls which can't throw).
-  Node* control = NodeProperties::GetControlInput(ret, 0);
-  bool found = (control->opcode() == IrOpcode::kIfSuccess)
-                   ? (NodeProperties::GetControlInput(control, 0) == call)
-                   : (control == NodeProperties::GetControlInput(call, 0));
-  return found ? call : nullptr;
-}
-
-}  // namespace
-
-
-void InstructionSelector::VisitReturn(Node* node) {
-  if (FLAG_turbo_tail_calls) {
-    Node* call = TryMatchTailCall(node);
-    if (call != nullptr) {
-      const CallDescriptor* desc = OpParameter<const CallDescriptor*>(call);
-      if (desc->UsesOnlyRegisters() &&
-          desc->HasSameReturnLocationsAs(linkage()->GetIncomingDescriptor())) {
-        return VisitCall(call, nullptr, TAIL_CALL);
-      }
-    }
-  }
-  Node* value = NodeProperties::GetValueInput(node, 0);
+void InstructionSelector::VisitReturn(Node* value) {
   DCHECK_NOT_NULL(value);
   OperandGenerator g(this);
   Emit(kArchRet, g.NoOutput(),
        g.UseLocation(value, linkage()->GetReturnLocation(),
                      linkage()->GetReturnType()));
 }
 
 
 void InstructionSelector::VisitDeoptimize(Node* value) {
   OperandGenerator g(this);
@@ skipping 110 matching lines @@
 
 
 #if !V8_TURBOFAN_BACKEND
 
 #define DECLARE_UNIMPLEMENTED_SELECTOR(x) \
   void InstructionSelector::Visit##x(Node* node) { UNIMPLEMENTED(); }
 MACHINE_OP_LIST(DECLARE_UNIMPLEMENTED_SELECTOR)
 #undef DECLARE_UNIMPLEMENTED_SELECTOR
 
 
-void InstructionSelector::VisitCall(Node* node, BasicBlock* handler,
-                                    CallMode call_mode) {
+void InstructionSelector::VisitCall(Node* node, BasicBlock* handler) {
   UNIMPLEMENTED();
 }
 
 
+void InstructionSelector::VisitTailCall(Node* node) { UNIMPLEMENTED(); }
+
+
 void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
                                       BasicBlock* fbranch) {
   UNIMPLEMENTED();
 }
 
 
 void InstructionSelector::VisitSwitch(Node* node, const SwitchInfo& sw) {
   UNIMPLEMENTED();
 }
 
 
 // static
 MachineOperatorBuilder::Flags
 InstructionSelector::SupportedMachineOperatorFlags() {
   return MachineOperatorBuilder::Flag::kNoFlags;
 }
 
 #endif  // !V8_TURBOFAN_BACKEND
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8