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