[turbofan] Support variable size argument popping in TF-generated functions

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"
@@ skipping 1871 matching lines @@
   call_instr->MarkAsCall();
 }
 
 
 void InstructionSelector::VisitTailCall(Node* node) {
   OperandGenerator g(this);
   CallDescriptor const* descriptor = CallDescriptorOf(node->op());
   DCHECK_NE(0, descriptor->flags() & CallDescriptor::kSupportsTailCalls);
 
   CallDescriptor* caller = linkage()->GetIncomingDescriptor();
-  if (caller->CanTailCall(node)) {
-    const CallDescriptor* callee = CallDescriptorOf(node->op());
-    int stack_param_delta = callee->GetStackParameterDelta(caller);
-    CallBuffer buffer(zone(), descriptor, nullptr);
+  DCHECK(caller->CanTailCall(node));
+  const CallDescriptor* callee = CallDescriptorOf(node->op());
+  int stack_param_delta = callee->GetStackParameterDelta(caller);
+  CallBuffer buffer(zone(), descriptor, nullptr);
 
-    // Compute InstructionOperands for inputs and outputs.
-    CallBufferFlags flags(kCallCodeImmediate | kCallTail);
-    if (IsTailCallAddressImmediate()) {
-      flags |= kCallAddressImmediate;
+  // Compute InstructionOperands for inputs and outputs.
+  CallBufferFlags flags(kCallCodeImmediate | kCallTail);
+  if (IsTailCallAddressImmediate()) {
+    flags |= kCallAddressImmediate;
     }
     InitializeCallBuffer(node, &buffer, flags, stack_param_delta);
 
     // Select the appropriate opcode based on the call type.
     InstructionCode opcode;
     InstructionOperandVector temps(zone());
     if (linkage()->GetIncomingDescriptor()->IsJSFunctionCall()) {
       switch (descriptor->kind()) {
         case CallDescriptor::kCallCodeObject:
           opcode = kArchTailCallCodeObjectFromJSFunction;
@@ skipping 31 matching lines @@
 
     int first_unused_stack_slot =
         (V8_TARGET_ARCH_STORES_RETURN_ADDRESS_ON_STACK ? 1 : 0) +
         stack_param_delta;
     buffer.instruction_args.push_back(g.TempImmediate(first_unused_stack_slot));
 
     // Emit the tailcall instruction.
     Emit(opcode, 0, nullptr, buffer.instruction_args.size(),
          &buffer.instruction_args.front(), temps.size(),
          temps.empty() ? nullptr : &temps.front());
-  } else {

[danno, 2016/10/25 06:43:32]

Given that return instructions now need to know how much extra they need to pop
from the stack, turning TailCalls into regular calls is no longer possible,
since it would require materializing that pop value from nothing... all other
reductions know where the get/inherit the value.

Besides, implicitly converting tail calls into something else seems unexpected
and we never should (or do) rely on it.

-    FrameStateDescriptor* frame_state_descriptor =
-        descriptor->NeedsFrameState()
-            ? GetFrameStateDescriptor(
-                  node->InputAt(static_cast<int>(descriptor->InputCount())))
-            : nullptr;
-
-    CallBuffer buffer(zone(), descriptor, frame_state_descriptor);
-
-    // Compute InstructionOperands for inputs and outputs.
-    CallBufferFlags flags = kCallCodeImmediate;
-    if (IsTailCallAddressImmediate()) {
-      flags |= kCallAddressImmediate;
-    }
-    InitializeCallBuffer(node, &buffer, flags);
-
-    EmitPrepareArguments(&(buffer.pushed_nodes), descriptor, node);
-
-    // Select the appropriate opcode based on the call type.
-    InstructionCode opcode;
-    switch (descriptor->kind()) {
-      case CallDescriptor::kCallCodeObject:
-        opcode = kArchCallCodeObject;
-        break;
-      case CallDescriptor::kCallJSFunction:
-        opcode = kArchCallJSFunction;
-        break;
-      default:
-        UNREACHABLE();
-        return;
-    }
-    opcode |= MiscField::encode(descriptor->flags());
-
-    // Emit the call instruction.
-    size_t output_count = buffer.outputs.size();
-    auto* outputs = &buffer.outputs.front();
-    Instruction* call_instr =
-        Emit(opcode, output_count, outputs, buffer.instruction_args.size(),
-             &buffer.instruction_args.front());
-    if (instruction_selection_failed()) return;
-    call_instr->MarkAsCall();
-    Emit(kArchRet, 0, nullptr, output_count, outputs);
-  }
 }
 
 
 void InstructionSelector::VisitGoto(BasicBlock* target) {
   // jump to the next block.
   OperandGenerator g(this);
   Emit(kArchJmp, g.NoOutput(), g.Label(target));
 }
 
-
 void InstructionSelector::VisitReturn(Node* ret) {
   OperandGenerator g(this);
-  if (linkage()->GetIncomingDescriptor()->ReturnCount() == 0) {
-    Emit(kArchRet, g.NoOutput());
-  } else {
-    const int ret_count = ret->op()->ValueInputCount();
-    auto value_locations = zone()->NewArray<InstructionOperand>(ret_count);
-    for (int i = 0; i < ret_count; ++i) {
-      value_locations[i] =
-          g.UseLocation(ret->InputAt(i), linkage()->GetReturnLocation(i));
-    }
-    Emit(kArchRet, 0, nullptr, ret_count, value_locations);
+  const int ret_count = linkage()->GetIncomingDescriptor()->ReturnCount() == 0
+                            ? 1
+                            : ret->op()->ValueInputCount();
+  DCHECK_GE(ret_count, 1);
+  auto value_locations = zone()->NewArray<InstructionOperand>(ret_count);
+  Node* pop_count = ret->InputAt(0);
+  value_locations[0] = pop_count->opcode() == IrOpcode::kInt32Constant
+                           ? g.UseImmediate(pop_count)
+                           : g.UseRegister(pop_count);
+  for (int i = 1; i < ret_count; ++i) {
+    value_locations[i] =
+        g.UseLocation(ret->InputAt(i), linkage()->GetReturnLocation(i - 1));
   }
+  Emit(kArchRet, 0, nullptr, ret_count, value_locations);
 }
 
 Instruction* InstructionSelector::EmitDeoptimize(
     InstructionCode opcode, InstructionOperand output, InstructionOperand a,
     InstructionOperand b, DeoptimizeReason reason, Node* frame_state) {
   size_t output_count = output.IsInvalid() ? 0 : 1;
   InstructionOperand inputs[] = {a, b};
   size_t input_count = arraysize(inputs);
   return EmitDeoptimize(opcode, output_count, &output, input_count, inputs,
                         reason, frame_state);
@@ skipping 107 matching lines @@
   return new (instruction_zone()) FrameStateDescriptor(
       instruction_zone(), state_info.type(), state_info.bailout_id(),
       state_info.state_combine(), parameters, locals, stack,
       state_info.shared_info(), outer_state);
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8