[turbofan] Frame elision for code stubs

src/compiler/frame.h

 // 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.
 
 #ifndef V8_COMPILER_FRAME_H_
 #define V8_COMPILER_FRAME_H_
 
 #include "src/bit-vector.h"
 #include "src/frames.h"
 
@@ skipping 63 matching lines @@
 //       |      ...        | Callee-saved               |
 //       |- - - - - - - - -|   |                        |
 // m+r+3 |  callee-saved r |   v                        v
 //  -----+-----------------+----- <-- stack ptr -------------
 //
 class Frame : public ZoneObject {
  public:
   explicit Frame(int fixed_frame_size_in_slots,
                  const CallDescriptor* descriptor);
 
-  inline bool needs_frame() const { return needs_frame_; }
-  inline void MarkNeedsFrame() { needs_frame_ = true; }
-
   inline int GetTotalFrameSlotCount() const { return frame_slot_count_; }
 
-  inline int GetSPToFPSlotCount() const {
-    return GetTotalFrameSlotCount() -
-           StandardFrameConstants::kFixedSlotCountAboveFp;
-  }
   inline int GetSavedCalleeRegisterSlotCount() const {
     return callee_saved_slot_count_;
   }
   inline int GetSpillSlotCount() const { return spill_slot_count_; }
 
-  inline void SetElidedFrameSizeInSlots(int slots) {
-    DCHECK_EQ(0, callee_saved_slot_count_);
-    DCHECK_EQ(0, spill_slot_count_);
-    frame_slot_count_ = slots;
-  }
-
   void SetAllocatedRegisters(BitVector* regs) {
     DCHECK(allocated_registers_ == nullptr);
     allocated_registers_ = regs;
   }
 
   void SetAllocatedDoubleRegisters(BitVector* regs) {
     DCHECK(allocated_double_registers_ == nullptr);
     allocated_double_registers_ = regs;
   }
 
   bool DidAllocateDoubleRegisters() const {
     return !allocated_double_registers_->IsEmpty();
   }
 
   int AlignSavedCalleeRegisterSlots(int alignment = kDoubleSize) {
     DCHECK_EQ(0, callee_saved_slot_count_);
     int alignment_slots = alignment / kPointerSize;
     int delta = alignment_slots - (frame_slot_count_ & (alignment_slots - 1));
     if (delta != alignment_slots) {
-      DCHECK(needs_frame_);
       frame_slot_count_ += delta;
     }
     return delta;
   }
 
   void AllocateSavedCalleeRegisterSlots(int count) {
-    needs_frame_ = true;
     frame_slot_count_ += count;
     callee_saved_slot_count_ += count;
   }
 
   int AllocateSpillSlot(int width) {
     DCHECK_EQ(0, callee_saved_slot_count_);
-    needs_frame_ = true;
     int frame_slot_count_before = frame_slot_count_;
     int slot = AllocateAlignedFrameSlot(width);
     spill_slot_count_ += (frame_slot_count_ - frame_slot_count_before);
     return slot;
   }
 
   int AlignFrame(int alignment = kDoubleSize);
 
   int ReserveSpillSlots(size_t slot_count) {
     DCHECK_EQ(0, callee_saved_slot_count_);
     DCHECK_EQ(0, spill_slot_count_);
-    needs_frame_ = true;
     spill_slot_count_ += static_cast<int>(slot_count);
     frame_slot_count_ += static_cast<int>(slot_count);
     return frame_slot_count_ - 1;
   }
 
   static const int kContextSlot = 2 + StandardFrameConstants::kCPSlotCount;
   static const int kJSFunctionSlot = 3 + StandardFrameConstants::kCPSlotCount;
 
  private:
   int AllocateAlignedFrameSlot(int width) {
     DCHECK(width == 4 || width == 8);
     // Skip one slot if necessary.
     if (width > kPointerSize) {
       DCHECK(width == kPointerSize * 2);
       frame_slot_count_++;
       frame_slot_count_ |= 1;
     }
     return frame_slot_count_++;
   }
 
  private:
-  bool needs_frame_;
   int frame_slot_count_;
   int callee_saved_slot_count_;
   int spill_slot_count_;
   BitVector* allocated_registers_;
   BitVector* allocated_double_registers_;
 
   DISALLOW_COPY_AND_ASSIGN(Frame);
 };
 
 
@@ skipping 21 matching lines @@
 
   static const int kFromSp = 1;
   static const int kFromFp = 0;
 };
 
 // Encapsulates the mutable state maintained during code generation about the
 // current function's frame.
 class FrameAccessState : public ZoneObject {
  public:
   explicit FrameAccessState(Frame* const frame)
-      : frame_(frame), access_frame_with_fp_(false), sp_delta_(0) {
-    SetFrameAccessToDefault();
-  }
+      : frame_(frame),
+        access_frame_with_fp_(false),
+        sp_delta_(0),
+        has_frame_(false),
+        deconstruct_frame_if_needed_(false),
+        return_block_deconstructs_(false) {}
 
   Frame* frame() const { return frame_; }
+  void MarkHasFrame(bool state);
 
   int sp_delta() const { return sp_delta_; }
   void ClearSPDelta() { sp_delta_ = 0; }
   void IncreaseSPDelta(int amount) { sp_delta_ += amount; }
 
   bool access_frame_with_fp() const { return access_frame_with_fp_; }
+
+  // Regardless of how we access slots on the stack - using sp or fp - do we
+  // have a frame, at the current stage in code generation.
+  bool has_frame() const { return has_frame_; }
+  bool deconstruct_frame_if_needed() const {
+    return deconstruct_frame_if_needed_;
+  }
+  void set_deconstruct_frame_if_needed(bool deconstruct) {

[danno, 2016/03/22 18:10:09]

I don't think this is needed, either. See code-generator.cc

+    deconstruct_frame_if_needed_ = deconstruct;
+  }
+
+  bool return_block_deconstructs() const { return return_block_deconstructs_; }
+  void MarkReturnBlockDeconstructs() {

[danno, 2016/03/22 18:10:09]

I don't think belongs on the frame_access_state, and I don't think it's what you
really want anyway.

I think what you want belongs on the code-generator, and it probably should look
different. Basically, you want to have two possible return labels, one that
deconstructs the frame, one that does not. Generate both, and jump to either the
one with or without frame destruction depending on the context you're coming
from.

+    DCHECK(!return_block_deconstructs_);
+    return_block_deconstructs_ = true;
+  }
   void SetFrameAccessToDefault();
   void SetFrameAccessToFP() { access_frame_with_fp_ = true; }
   void SetFrameAccessToSP() { access_frame_with_fp_ = false; }
 
   int GetSPToFPSlotCount() const {
-    return frame_->GetSPToFPSlotCount() + sp_delta();
+    int frame_slot_count =
+        (has_frame() ? frame()->GetTotalFrameSlotCount() : kElidedFrameSlots) -
+        StandardFrameConstants::kFixedSlotCountAboveFp;
+    return frame_slot_count + sp_delta();
   }
   int GetSPToFPOffset() const { return GetSPToFPSlotCount() * kPointerSize; }
 
   // Get the frame offset for a given spill slot. The location depends on the
   // calling convention and the specific frame layout, and may thus be
   // architecture-specific. Negative spill slots indicate arguments on the
   // caller's frame.
   FrameOffset GetFrameOffset(int spill_slot) const;
 
  private:
   Frame* const frame_;
   bool access_frame_with_fp_;
   int sp_delta_;
+  bool has_frame_;
+  bool deconstruct_frame_if_needed_;
+  bool return_block_deconstructs_;
 };
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_FRAME_H_