[turbofan] Implement tail calls with differing stack parameter counts

src/compiler/ia32/code-generator-ia32.cc

 // Copyright 2013 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/code-generator.h"
 
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/gap-resolver.h"
 #include "src/compiler/node-matchers.h"
 #include "src/ia32/assembler-ia32.h"
@@ skipping 266 matching lines @@
     __ j(above_equal, &done, Label::kNear);                  \
     if (instr->InputAt(2)->IsRegister()) {                   \
       __ asm_instr(i.MemoryOperand(3), i.InputRegister(2));  \
     } else {                                                 \
       __ asm_instr(i.MemoryOperand(3), i.InputImmediate(2)); \
     }                                                        \
     __ bind(&done);                                          \
   } while (false)
 
 
-void CodeGenerator::AssembleDeconstructActivationRecord() {
-  CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
-  int stack_slots = frame()->GetSpillSlotCount();
-  if (descriptor->IsJSFunctionCall() || stack_slots > 0) {
-    __ mov(esp, ebp);
-    __ pop(ebp);
+void CodeGenerator::AssembleTailCallSetup(Instruction* instr) {

[Benedikt Meurer, 2015/07/30 06:47:24]

This is quite a lot of (complex) per-architecture code. I have a bad feeling
about this. Can we make this into explicit instruction opcodes at least and do
this magic as part of the instruction selection? This code within code approach
frightens me.

+  IA32OperandConverter i(this, instr);
+  size_t current_argument = instr->InputCount() - 1;
+  int stack_delta = ImmediateOperand::cast(instr->InputAt(current_argument--))
+                        ->inline_value();
+  int pushed_parameters =
+      ImmediateOperand::cast(instr->InputAt(current_argument--))
+          ->inline_value();
+  int base_offset = pushed_parameters * kPointerSize;
+  int frame_size = (StandardFrameConstants::kCallerPCOffset -
+                    StandardFrameConstants::kMarkerOffset) +
+                   frame()->GetFrameSlotCount() * kPointerSize;
+  if (frame()->NeedsFrame()) {
+    base_offset += frame_size;
   }
+
+  if (frame()->NeedsFrame() && stack_delta != 0) {
+    __ mov(ebp, Operand(ebp, 0));
+  }
+
+  bool done = false;
+  Register return_reg = no_reg;
+  while (!done) {
+    TailCallOpcode opcode = static_cast<TailCallOpcode>(
+        ImmediateOperand::cast(instr->InputAt(current_argument--))
+            ->inline_value());
+    switch (opcode) {
+      case kPopAndStore: {
+        int location =
+            ImmediateOperand::cast(instr->InputAt(current_argument--))
+                ->inline_value();
+        DCHECK(location != 0);
+        DCHECK(frame()->NeedsFrame());  // Tail calls from elided frames that
+                                        // require pushing arguments are not
+                                        // supported.
+        base_offset -= kPointerSize;
+        __ pop(Operand(esp, base_offset + location * kPointerSize));
+        break;
+      }
+      case kStore: {
+        size_t arg = current_argument--;
+        if (HasImmediateInput(instr, arg)) {
+          Immediate value_immediate = i.InputImmediate(arg);
+          int location =
+              ImmediateOperand::cast(instr->InputAt(current_argument--))
+                  ->inline_value();
+          DCHECK(location != 0);
+          __ mov(Operand(esp, base_offset + location * kPointerSize),
+                 value_immediate);
+        } else {
+          Register value_reg = i.InputRegister(arg);
+          int location =
+              ImmediateOperand::cast(instr->InputAt(current_argument--))
+                  ->inline_value();
+          DCHECK(location != 0);
+          __ mov(Operand(esp, base_offset + location * kPointerSize),
+                 value_reg);
+        }
+        break;
+      }
+      case kReplaceReturn: {
+        return_reg = i.InputRegister(current_argument--);
+        DCHECK(return_reg.is_valid());
+        __ xchg(return_reg, Operand(esp, base_offset));
+        break;
+      }
+      case kDeconstructFrame: {
+        if (stack_delta > 0) {
+          int delta = (frame()->NeedsFrame() ? frame_size : 0) -
+                      (stack_delta - 1) * kPointerSize;
+          if (delta != 0) {
+            if (delta < 0) {
+              __ sub(esp, Immediate(-delta));
+            } else {
+              __ add(esp, Immediate(delta));
+            }
+            base_offset -= delta;
+          }
+        } else if (stack_delta < 0) {
+          if (frame()->NeedsFrame()) {
+            __ add(esp, Immediate(frame_size));
+            base_offset -= frame_size;
+          }
+          int delta = (-stack_delta - 1) * kPointerSize;
+          base_offset -= kPointerSize;
+          __ pop(Operand(esp, delta));
+          if (stack_delta != -1) {
+            if (delta < 0) {
+              __ sub(esp, Immediate(-delta));
+            } else {
+              __ add(esp, Immediate(delta));
+            }
+            base_offset -= delta;
+          }
+        } else {
+          if (frame()->NeedsFrame()) {
+            __ mov(esp, ebp);
+            __ pop(ebp);
+            base_offset -= frame_size;
+          }
+        }
+        break;
+      }
+      case kParametersReady: {
+        if (stack_delta > 0) {
+          __ push(return_reg);
+          base_offset += kPointerSize;
+        }
+        done = true;
+        break;
+      }
+    }
+  }
+
+  // Ensure all of the stack tracking math ends up at the end matching the
+  // predicted delta.
+  DCHECK_EQ(stack_delta * kPointerSize, base_offset);
 }
 
 
 // Assembles an instruction after register allocation, producing machine code.
 void CodeGenerator::AssembleArchInstruction(Instruction* instr) {
   IA32OperandConverter i(this, instr);
 
   switch (ArchOpcodeField::decode(instr->opcode())) {
     case kArchCallCodeObject: {
       EnsureSpaceForLazyDeopt();
       if (HasImmediateInput(instr, 0)) {
         Handle<Code> code = Handle<Code>::cast(i.InputHeapObject(0));
         __ call(code, RelocInfo::CODE_TARGET);
       } else {
         Register reg = i.InputRegister(0);
         __ call(Operand(reg, Code::kHeaderSize - kHeapObjectTag));
       }
       RecordCallPosition(instr);
       break;
     }
     case kArchTailCallCodeObject: {
-      AssembleDeconstructActivationRecord();
+      AssembleTailCallSetup(instr);
       if (HasImmediateInput(instr, 0)) {
         Handle<Code> code = Handle<Code>::cast(i.InputHeapObject(0));
         __ jmp(code, RelocInfo::CODE_TARGET);
       } else {
         Register reg = i.InputRegister(0);
         __ jmp(Operand(reg, Code::kHeaderSize - kHeapObjectTag));
       }
       break;
     }
     case kArchCallJSFunction: {
       EnsureSpaceForLazyDeopt();
       Register func = i.InputRegister(0);
       if (FLAG_debug_code) {
         // Check the function's context matches the context argument.
         __ cmp(esi, FieldOperand(func, JSFunction::kContextOffset));
         __ Assert(equal, kWrongFunctionContext);
       }
       __ call(FieldOperand(func, JSFunction::kCodeEntryOffset));
       RecordCallPosition(instr);
       break;
     }
     case kArchTailCallJSFunction: {
       Register func = i.InputRegister(0);
       if (FLAG_debug_code) {
         // Check the function's context matches the context argument.
         __ cmp(esi, FieldOperand(func, JSFunction::kContextOffset));
         __ Assert(equal, kWrongFunctionContext);
       }
-      AssembleDeconstructActivationRecord();
+      AssembleTailCallSetup(instr);
       __ jmp(FieldOperand(func, JSFunction::kCodeEntryOffset));
       break;
     }
     case kArchPrepareCallCFunction: {
       int const num_parameters = MiscField::decode(instr->opcode());
       __ PrepareCallCFunction(num_parameters, i.TempRegister(0));
       break;
     }
     case kArchCallCFunction: {
       int const num_parameters = MiscField::decode(instr->opcode());
@@ skipping 511 matching lines @@
           __ shl(i.OutputRegister(), 3);
         } else {
           __ lea(i.OutputRegister(), i.MemoryOperand());
         }
       } else {
         __ lea(i.OutputRegister(), i.MemoryOperand());
       }
       break;
     }
     case kIA32Push:
+      // Pushes and pops require a frame, otherwise parameter access, which is
+      // esp-relative would be off.
+      DCHECK(frame()->NeedsFrame());
       if (HasImmediateInput(instr, 0)) {
         __ push(i.InputImmediate(0));
       } else {
         __ push(i.InputOperand(0));
       }
       break;
     case kIA32Poke: {
       int const slot = MiscField::decode(instr->opcode());
       if (HasImmediateInput(instr, 0)) {
         __ mov(Operand(esp, slot * kPointerSize), i.InputImmediate(0));
@@ skipping 362 matching lines @@
 //                                       | FP | RET | args |  caller frame |
 //                                       ^ esp,ebp
 
 // --{ pop ebp }----------------------------------------------------------------
 //                                            | RET | args |  caller frame |
 //                                            ^ esp                        ^ ebp
 
 
 void CodeGenerator::AssemblePrologue() {
   CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
-  int stack_slots = frame()->GetSpillSlotCount();
+  int stack_slots = frame()->GetFrameSlotCount();
   if (descriptor->kind() == CallDescriptor::kCallAddress) {
     // Assemble a prologue similar the to cdecl calling convention.
     __ push(ebp);
     __ mov(ebp, esp);
     const RegList saves = descriptor->CalleeSavedRegisters();
     if (saves != 0) {  // Save callee-saved registers.
       int register_save_area_size = 0;
       for (int i = Register::kNumRegisters - 1; i >= 0; i--) {
         if (!((1 << i) & saves)) continue;
         __ push(Register::from_code(i));
         register_save_area_size += kPointerSize;
       }
       frame()->SetRegisterSaveAreaSize(register_save_area_size);
     }
-  } else if (descriptor->IsJSFunctionCall()) {
+  } else if (frame()->NeedsFrame()) {
     // TODO(turbofan): this prologue is redundant with OSR, but needed for
     // code aging.
     CompilationInfo* info = this->info();
-    __ Prologue(info->IsCodePreAgingActive());
-    frame()->SetRegisterSaveAreaSize(
-        StandardFrameConstants::kFixedFrameSizeFromFp);
-  } else if (needs_frame_) {
-    __ StubPrologue();
+    if (descriptor->IsJSFunctionCall()) {
+      __ Prologue(info->IsCodePreAgingActive());
+    } else {
+      __ StubPrologue();
+    }
     frame()->SetRegisterSaveAreaSize(
         StandardFrameConstants::kFixedFrameSizeFromFp);
   }
 
   if (info()->is_osr()) {
     // TurboFan OSR-compiled functions cannot be entered directly.
     __ Abort(kShouldNotDirectlyEnterOsrFunction);
 
     // Unoptimized code jumps directly to this entrypoint while the unoptimized
     // frame is still on the stack. Optimized code uses OSR values directly from
     // the unoptimized frame. Thus, all that needs to be done is to allocate the
     // remaining stack slots.
     if (FLAG_code_comments) __ RecordComment("-- OSR entrypoint --");
     osr_pc_offset_ = __ pc_offset();
     // TODO(titzer): cannot address target function == local #-1
     __ mov(edi, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
     DCHECK(stack_slots >= frame()->GetOsrStackSlotCount());
     stack_slots -= frame()->GetOsrStackSlotCount();
   }
 
   if (stack_slots > 0) {
     // Allocate the stack slots used by this frame.
     __ sub(esp, Immediate(stack_slots * kPointerSize));
   }
 }
 
 
 void CodeGenerator::AssembleReturn() {
   CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
-  int stack_slots = frame()->GetSpillSlotCount();
+  int stack_slots = frame()->GetFrameSlotCount();
   if (descriptor->kind() == CallDescriptor::kCallAddress) {
     const RegList saves = descriptor->CalleeSavedRegisters();
     if (frame()->GetRegisterSaveAreaSize() > 0) {
       // Remove this frame's spill slots first.
       if (stack_slots > 0) {
         __ add(esp, Immediate(stack_slots * kPointerSize));
       }
       // Restore registers.
       if (saves != 0) {
         for (int i = 0; i < Register::kNumRegisters; i++) {
           if (!((1 << i) & saves)) continue;
           __ pop(Register::from_code(i));
         }
       }
       __ pop(ebp);  // Pop caller's frame pointer.
       __ ret(0);
     } else {
       // No saved registers.
       __ mov(esp, ebp);  // Move stack pointer back to frame pointer.
       __ pop(ebp);       // Pop caller's frame pointer.
       __ ret(0);
     }
-  } else if (descriptor->IsJSFunctionCall() || needs_frame_) {
+  } else if (frame()->NeedsFrame()) {
     // Canonicalize JSFunction return sites for now.
     if (return_label_.is_bound()) {
       __ jmp(&return_label_);
     } else {
       __ bind(&return_label_);
       __ mov(esp, ebp);  // Move stack pointer back to frame pointer.
       __ pop(ebp);       // Pop caller's frame pointer.
       int pop_count = descriptor->IsJSFunctionCall()
                           ? static_cast<int>(descriptor->JSParameterCount())
                           : (info()->IsStub()
@@ skipping 196 matching lines @@
       __ Nop(padding_size);
     }
   }
 }
 
 #undef __
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8