1 // Copyright 2014 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #ifndef V8_COMPILER_FRAME_H_
6 #define V8_COMPILER_FRAME_H_
7 
8 #include "src/bit-vector.h"
9 #include "src/frames.h"
10 
11 namespace v8 {
12 namespace internal {
13 namespace compiler {
14 
15 class CallDescriptor;
16 
17 // Collects the spill slot and other frame slot requirements for a compiled
18 // function. Frames are usually populated by the register allocator and are used
19 // by Linkage to generate code for the prologue and epilogue to compiled
20 // code. Frame objects must be considered immutable once they've been
21 // instantiated and the basic information about the frame has been collected
22 // into them. Mutable state associated with the frame is stored separately in
23 // FrameAccessState.
24 //
25 // Frames are divided up into three regions.
26 // - The first is the fixed header, which always has a constant size and can be
27 //   predicted before code generation begins depending on the type of code being
28 //   generated.
29 // - The second is the region for spill slots, which is immediately below the
30 //   fixed header and grows as the register allocator needs to spill to the
31 //   stack and asks the frame for more space.
32 // - The third region, which contains the callee-saved registers must be
33 //   reserved after register allocation, since its size can only be precisely
34 //   determined after register allocation once the number of used callee-saved
35 //   register is certain.
36 //
37 // The frame region immediately below the fixed header contains spill slots
38 // starting at slot 4 for JSFunctions.  The callee-saved frame region below that
39 // starts at 4+spill_slot_count_.  Callee stack slots corresponding to
40 // parameters are accessible through negative slot ids.
41 //
42 // Every slot of a caller or callee frame is accessible by the register
43 // allocator and gap resolver with a SpillSlotOperand containing its
44 // corresponding slot id.
45 //
46 // Below an example JSFunction Frame with slot ids, frame regions and contents:
47 //
48 //  slot      JS frame
49 //       +-----------------+--------------------------------
50 //  -n-1 |   parameter 0   |                            ^
51 //       |- - - - - - - - -|                            |
52 //  -n   |                 |                          Caller
53 //  ...  |       ...       |                       frame slots
54 //  -2   |  parameter n-1  |                       (slot < 0)
55 //       |- - - - - - - - -|                            |
56 //  -1   |   parameter n   |                            v
57 //  -----+-----------------+--------------------------------
58 //   0   |   return addr   |   ^                        ^
59 //       |- - - - - - - - -|   |                        |
60 //   1   | saved frame ptr | Fixed                      |
61 //       |- - - - - - - - -| Header <-- frame ptr       |
62 //   2   |Context/Frm. Type|   |                        |
63 //       |- - - - - - - - -|   |                        |
64 //   3   |   [JSFunction]  |   v                        |
65 //       +-----------------+----                        |
66 //   4   |    spill 1      |   ^                      Callee
67 //       |- - - - - - - - -|   |                   frame slots
68 //  ...  |      ...        | Spill slots           (slot >= 0)
69 //       |- - - - - - - - -|   |                        |
70 //  m+3  |    spill m      |   v                        |
71 //       +-----------------+----                        |
72 //  m+4  |  callee-saved 1 |   ^                        |
73 //       |- - - - - - - - -|   |                        |
74 //       |      ...        | Callee-saved               |
75 //       |- - - - - - - - -|   |                        |
76 // m+r+3 |  callee-saved r |   v                        v
77 //  -----+-----------------+----- <-- stack ptr -------------
78 //
79 class Frame : public ZoneObject {
80  public:
81   explicit Frame(int fixed_frame_size_in_slots);
82 
GetTotalFrameSlotCount()83   inline int GetTotalFrameSlotCount() const { return frame_slot_count_; }
84 
GetSpillSlotCount()85   inline int GetSpillSlotCount() const { return spill_slot_count_; }
86 
SetAllocatedRegisters(BitVector * regs)87   void SetAllocatedRegisters(BitVector* regs) {
88     DCHECK(allocated_registers_ == nullptr);
89     allocated_registers_ = regs;
90   }
91 
SetAllocatedDoubleRegisters(BitVector * regs)92   void SetAllocatedDoubleRegisters(BitVector* regs) {
93     DCHECK(allocated_double_registers_ == nullptr);
94     allocated_double_registers_ = regs;
95   }
96 
DidAllocateDoubleRegisters()97   bool DidAllocateDoubleRegisters() const {
98     return !allocated_double_registers_->IsEmpty();
99   }
100 
101   void AlignSavedCalleeRegisterSlots(int alignment = kDoubleSize) {
102     int alignment_slots = alignment / kPointerSize;
103     int delta = alignment_slots - (frame_slot_count_ & (alignment_slots - 1));
104     if (delta != alignment_slots) {
105       frame_slot_count_ += delta;
106     }
107     spill_slot_count_ += delta;
108   }
109 
AllocateSavedCalleeRegisterSlots(int count)110   void AllocateSavedCalleeRegisterSlots(int count) {
111     frame_slot_count_ += count;
112   }
113 
AllocateSpillSlot(int width)114   int AllocateSpillSlot(int width) {
115     int frame_slot_count_before = frame_slot_count_;
116     int slot = AllocateAlignedFrameSlot(width);
117     spill_slot_count_ += (frame_slot_count_ - frame_slot_count_before);
118     return slot;
119   }
120 
121   int AlignFrame(int alignment = kDoubleSize);
122 
ReserveSpillSlots(size_t slot_count)123   int ReserveSpillSlots(size_t slot_count) {
124     DCHECK_EQ(0, spill_slot_count_);
125     spill_slot_count_ += static_cast<int>(slot_count);
126     frame_slot_count_ += static_cast<int>(slot_count);
127     return frame_slot_count_ - 1;
128   }
129 
130   static const int kContextSlot = 2 + StandardFrameConstants::kCPSlotCount;
131   static const int kJSFunctionSlot = 3 + StandardFrameConstants::kCPSlotCount;
132 
133  private:
AllocateAlignedFrameSlot(int width)134   int AllocateAlignedFrameSlot(int width) {
135     DCHECK(width == 4 || width == 8 || width == 16);
136     if (kPointerSize == 4) {
137       // Skip one slot if necessary.
138       if (width > kPointerSize) {
139         frame_slot_count_++;
140         frame_slot_count_ |= 1;
141         // 2 extra slots if width == 16.
142         frame_slot_count_ += (width & 16) / 8;
143       }
144     } else {
145       // No alignment when slots are 8 bytes.
146       DCHECK_EQ(8, kPointerSize);
147       // 1 extra slot if width == 16.
148       frame_slot_count_ += (width & 16) / 16;
149     }
150     return frame_slot_count_++;
151   }
152 
153  private:
154   int frame_slot_count_;
155   int spill_slot_count_;
156   BitVector* allocated_registers_;
157   BitVector* allocated_double_registers_;
158 
159   DISALLOW_COPY_AND_ASSIGN(Frame);
160 };
161 
162 
163 // Represents an offset from either the stack pointer or frame pointer.
164 class FrameOffset {
165  public:
from_stack_pointer()166   inline bool from_stack_pointer() { return (offset_ & 1) == kFromSp; }
from_frame_pointer()167   inline bool from_frame_pointer() { return (offset_ & 1) == kFromFp; }
offset()168   inline int offset() { return offset_ & ~1; }
169 
FromStackPointer(int offset)170   inline static FrameOffset FromStackPointer(int offset) {
171     DCHECK((offset & 1) == 0);
172     return FrameOffset(offset | kFromSp);
173   }
174 
FromFramePointer(int offset)175   inline static FrameOffset FromFramePointer(int offset) {
176     DCHECK((offset & 1) == 0);
177     return FrameOffset(offset | kFromFp);
178   }
179 
180  private:
FrameOffset(int offset)181   explicit FrameOffset(int offset) : offset_(offset) {}
182 
183   int offset_;  // Encodes SP or FP in the low order bit.
184 
185   static const int kFromSp = 1;
186   static const int kFromFp = 0;
187 };
188 
189 // Encapsulates the mutable state maintained during code generation about the
190 // current function's frame.
191 class FrameAccessState : public ZoneObject {
192  public:
FrameAccessState(const Frame * const frame)193   explicit FrameAccessState(const Frame* const frame)
194       : frame_(frame),
195         access_frame_with_fp_(false),
196         sp_delta_(0),
197         has_frame_(false) {}
198 
frame()199   const Frame* frame() const { return frame_; }
200   void MarkHasFrame(bool state);
201 
sp_delta()202   int sp_delta() const { return sp_delta_; }
ClearSPDelta()203   void ClearSPDelta() { sp_delta_ = 0; }
IncreaseSPDelta(int amount)204   void IncreaseSPDelta(int amount) { sp_delta_ += amount; }
205 
access_frame_with_fp()206   bool access_frame_with_fp() const { return access_frame_with_fp_; }
207 
208   // Regardless of how we access slots on the stack - using sp or fp - do we
209   // have a frame, at the current stage in code generation.
has_frame()210   bool has_frame() const { return has_frame_; }
211 
212   void SetFrameAccessToDefault();
SetFrameAccessToFP()213   void SetFrameAccessToFP() { access_frame_with_fp_ = true; }
SetFrameAccessToSP()214   void SetFrameAccessToSP() { access_frame_with_fp_ = false; }
215 
GetSPToFPSlotCount()216   int GetSPToFPSlotCount() const {
217     int frame_slot_count =
218         (has_frame() ? frame()->GetTotalFrameSlotCount() : kElidedFrameSlots) -
219         StandardFrameConstants::kFixedSlotCountAboveFp;
220     return frame_slot_count + sp_delta();
221   }
GetSPToFPOffset()222   int GetSPToFPOffset() const { return GetSPToFPSlotCount() * kPointerSize; }
223 
224   // Get the frame offset for a given spill slot. The location depends on the
225   // calling convention and the specific frame layout, and may thus be
226   // architecture-specific. Negative spill slots indicate arguments on the
227   // caller's frame.
228   FrameOffset GetFrameOffset(int spill_slot) const;
229 
230  private:
231   const Frame* const frame_;
232   bool access_frame_with_fp_;
233   int sp_delta_;
234   bool has_frame_;
235 };
236 }  // namespace compiler
237 }  // namespace internal
238 }  // namespace v8
239 
240 #endif  // V8_COMPILER_FRAME_H_
241