[turbofan]: Implement tail calls with more callee than caller parameters

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 489 matching lines @@
       }
       DCHECK(!buffer->pushed_nodes[stack_index]);
       buffer->pushed_nodes[stack_index] = *iter;
       pushed_count++;
     } else {
       buffer->instruction_args.push_back(op);
     }
   }
   DCHECK_EQ(input_count, buffer->instruction_args.size() + pushed_count -
                              buffer->frame_state_value_count());
+  if (call_tail && stack_param_delta != 0) {
+    // For tail calls that change the size of their parameter list, move the
+    // saved caller return address, parent frame pointer and parent constant
+    // pool pointer to just above the parameters.
+
+    // Return address
+    LinkageLocation saved_return_location =
+        LinkageLocation::ForSavedCallerReturnAddress();
+    InstructionOperand return_address =
+        g.UsePointerLocation(LinkageLocation::ConvertToTailCallerLocation(
+                                 saved_return_location, stack_param_delta),
+                             saved_return_location);
+    buffer->instruction_args.push_back(return_address);
+
+    // Parent frame pointer
+    LinkageLocation saved_frame_location =
+        LinkageLocation::ForSavedCallerFramePtr();
+    InstructionOperand saved_frame =
+        g.UsePointerLocation(LinkageLocation::ConvertToTailCallerLocation(
+                                 saved_frame_location, stack_param_delta),
+                             saved_frame_location);
+    buffer->instruction_args.push_back(saved_frame);
+
+    if (V8_EMBEDDED_CONSTANT_POOL) {
+      // Constant pool pointer
+      LinkageLocation saved_cp_location =
+          LinkageLocation::ForSavedCallerConstantPool();
+      InstructionOperand saved_cp =
+          g.UsePointerLocation(LinkageLocation::ConvertToTailCallerLocation(
+                                   saved_cp_location, stack_param_delta),
+                               saved_cp_location);
+      buffer->instruction_args.push_back(saved_cp);
+    }
+  }
 }
 
 
 void InstructionSelector::VisitBlock(BasicBlock* block) {
   DCHECK(!current_block_);
   current_block_ = block;
   int current_block_end = static_cast<int>(instructions_.size());
 
   // Generate code for the block control "top down", but schedule the code
   // "bottom up".
@@ skipping 760 matching lines @@
         opcode = kArchTailCallJSFunction;
         break;
       default:
         UNREACHABLE();
         return;
     }
     opcode |= MiscField::encode(descriptor->flags());
 
     buffer.instruction_args.push_back(g.TempImmediate(stack_param_delta));
 
+    Emit(kArchPrepareTailCall, g.NoOutput(),
+         g.TempImmediate(stack_param_delta));
+
     // Emit the tailcall instruction.
     Emit(opcode, 0, nullptr, buffer.instruction_args.size(),
          &buffer.instruction_args.front());
   } else {
     FrameStateDescriptor* frame_state_descriptor =
         descriptor->NeedsFrameState()
             ? GetFrameStateDescriptor(
                   node->InputAt(static_cast<int>(descriptor->InputCount())))
             : nullptr;
 
@@ skipping 111 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