| // 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/execution/frame-constants.h" |
| #include "src/utils/bit-vector.h" |
| |
| namespace v8 { |
| namespace internal { |
| namespace compiler { |
| |
| class CallDescriptor; |
| |
| // Collects the spill slot and other frame slot requirements for a compiled |
| // function. Frames are usually populated by the register allocator and are used |
| // by Linkage to generate code for the prologue and epilogue to compiled |
| // code. Frame objects must be considered immutable once they've been |
| // instantiated and the basic information about the frame has been collected |
| // into them. Mutable state associated with the frame is stored separately in |
| // FrameAccessState. |
| // |
| // Frames are divided up into four regions. |
| // - The first is the fixed header, which always has a constant size and can be |
| // predicted before code generation begins depending on the type of code being |
| // generated. |
| // - The second is the region for spill slots, which is immediately below the |
| // fixed header and grows as the register allocator needs to spill to the |
| // stack and asks the frame for more space. |
| // - The third region, which contains the callee-saved registers must be |
| // reserved after register allocation, since its size can only be precisely |
| // determined after register allocation once the number of used callee-saved |
| // register is certain. |
| // - The fourth region is a scratch area for return values from other functions |
| // called, if multiple returns cannot all be passed in registers. This region |
| // Must be last in a stack frame, so that it is positioned immediately below |
| // the stack frame of a callee to store to. |
| // |
| // The frame region immediately below the fixed header contains spill slots |
| // starting at slot 4 for JSFunctions. The callee-saved frame region below that |
| // starts at 4+spill_slot_count_. Callee stack slots correspond to |
| // parameters that are accessible through negative slot ids. |
| // |
| // Every slot of a caller or callee frame is accessible by the register |
| // allocator and gap resolver with a SpillSlotOperand containing its |
| // corresponding slot id. |
| // |
| // Below an example JSFunction Frame with slot ids, frame regions and contents: |
| // |
| // slot JS frame |
| // +-----------------+-------------------------------- |
| // -n-1 | parameter 0 | ^ |
| // |- - - - - - - - -| | |
| // -n | | Caller |
| // ... | ... | frame slots |
| // -2 | parameter n-1 | (slot < 0) |
| // |- - - - - - - - -| | |
| // -1 | parameter n | v |
| // -----+-----------------+-------------------------------- |
| // 0 | return addr | ^ ^ |
| // |- - - - - - - - -| | | |
| // 1 | saved frame ptr | Fixed | |
| // |- - - - - - - - -| Header <-- frame ptr | |
| // 2 |Context/Frm. Type| | | |
| // |- - - - - - - - -| | | |
| // 3 | [JSFunction] | v | |
| // +-----------------+---- | |
| // 4 | spill 1 | ^ Callee |
| // |- - - - - - - - -| | frame slots |
| // ... | ... | Spill slots (slot >= 0) |
| // |- - - - - - - - -| | | |
| // m+3 | spill m | v | |
| // +-----------------+---- | |
| // m+4 | callee-saved 1 | ^ | |
| // |- - - - - - - - -| | | |
| // | ... | Callee-saved | |
| // |- - - - - - - - -| | | |
| // m+r+3 | callee-saved r | v | |
| // +-----------------+---- | |
| // m+r+4 | return 0 | ^ | |
| // |- - - - - - - - -| | | |
| // | ... | Return | |
| // |- - - - - - - - -| | | |
| // | return q-1 | v v |
| // -----+-----------------+----- <-- stack ptr ------------- |
| // |
| class V8_EXPORT_PRIVATE Frame : public ZoneObject { |
| public: |
| explicit Frame(int fixed_frame_size_in_slots); |
| |
| inline int GetTotalFrameSlotCount() const { return frame_slot_count_; } |
| inline int GetFixedSlotCount() const { return fixed_slot_count_; } |
| inline int GetSpillSlotCount() const { return spill_slot_count_; } |
| inline int GetReturnSlotCount() const { return return_slot_count_; } |
| |
| void SetAllocatedRegisters(BitVector* regs) { |
| DCHECK_NULL(allocated_registers_); |
| allocated_registers_ = regs; |
| } |
| |
| void SetAllocatedDoubleRegisters(BitVector* regs) { |
| DCHECK_NULL(allocated_double_registers_); |
| allocated_double_registers_ = regs; |
| } |
| |
| bool DidAllocateDoubleRegisters() const { |
| return !allocated_double_registers_->IsEmpty(); |
| } |
| |
| void AlignSavedCalleeRegisterSlots(int alignment = kDoubleSize) { |
| int alignment_slots = alignment / kSystemPointerSize; |
| int delta = alignment_slots - (frame_slot_count_ & (alignment_slots - 1)); |
| if (delta != alignment_slots) { |
| frame_slot_count_ += delta; |
| } |
| spill_slot_count_ += delta; |
| } |
| |
| void AllocateSavedCalleeRegisterSlots(int count) { |
| frame_slot_count_ += count; |
| } |
| |
| int AllocateSpillSlot(int width, int alignment = 0) { |
| DCHECK_EQ(frame_slot_count_, |
| fixed_slot_count_ + spill_slot_count_ + return_slot_count_); |
| int frame_slot_count_before = frame_slot_count_; |
| if (alignment > kSystemPointerSize) { |
| // Slots are pointer sized, so alignment greater than a pointer size |
| // requires allocating additional slots. |
| width += alignment - kSystemPointerSize; |
| } |
| AllocateAlignedFrameSlots(width); |
| spill_slot_count_ += frame_slot_count_ - frame_slot_count_before; |
| return frame_slot_count_ - return_slot_count_ - 1; |
| } |
| |
| void EnsureReturnSlots(int count) { |
| if (count > return_slot_count_) { |
| count -= return_slot_count_; |
| frame_slot_count_ += count; |
| return_slot_count_ += count; |
| } |
| } |
| |
| int AlignFrame(int alignment = kDoubleSize); |
| |
| int ReserveSpillSlots(size_t slot_count) { |
| DCHECK_EQ(0, spill_slot_count_); |
| spill_slot_count_ += static_cast<int>(slot_count); |
| frame_slot_count_ += static_cast<int>(slot_count); |
| return frame_slot_count_ - 1; |
| } |
| |
| private: |
| void AllocateAlignedFrameSlots(int width) { |
| DCHECK_LT(0, width); |
| int new_frame_slots = (width + kSystemPointerSize - 1) / kSystemPointerSize; |
| // Align to 8 bytes if width is a multiple of 8 bytes, and to 16 bytes if |
| // multiple of 16. |
| int align_to = |
| (width & 15) == 0 ? 16 : (width & 7) == 0 ? 8 : kSystemPointerSize; |
| frame_slot_count_ = RoundUp(frame_slot_count_ + new_frame_slots, |
| align_to / kSystemPointerSize); |
| DCHECK_LT(0, frame_slot_count_); |
| } |
| |
| private: |
| int fixed_slot_count_; |
| int frame_slot_count_; |
| int spill_slot_count_; |
| int return_slot_count_; |
| BitVector* allocated_registers_; |
| BitVector* allocated_double_registers_; |
| |
| DISALLOW_COPY_AND_ASSIGN(Frame); |
| }; |
| |
| // Represents an offset from either the stack pointer or frame pointer. |
| class FrameOffset { |
| public: |
| inline bool from_stack_pointer() { return (offset_ & 1) == kFromSp; } |
| inline bool from_frame_pointer() { return (offset_ & 1) == kFromFp; } |
| inline int offset() { return offset_ & ~1; } |
| |
| inline static FrameOffset FromStackPointer(int offset) { |
| DCHECK_EQ(0, offset & 1); |
| return FrameOffset(offset | kFromSp); |
| } |
| |
| inline static FrameOffset FromFramePointer(int offset) { |
| DCHECK_EQ(0, offset & 1); |
| return FrameOffset(offset | kFromFp); |
| } |
| |
| private: |
| explicit FrameOffset(int offset) : offset_(offset) {} |
| |
| int offset_; // Encodes SP or FP in the low order bit. |
| |
| 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(const Frame* const frame) |
| : frame_(frame), |
| access_frame_with_fp_(false), |
| sp_delta_(0), |
| has_frame_(false) {} |
| |
| const Frame* frame() const { return frame_; } |
| V8_EXPORT_PRIVATE 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_; } |
| |
| void SetFrameAccessToDefault(); |
| void SetFrameAccessToFP() { access_frame_with_fp_ = true; } |
| void SetFrameAccessToSP() { access_frame_with_fp_ = false; } |
| |
| int GetSPToFPSlotCount() const { |
| int frame_slot_count = |
| (has_frame() ? frame()->GetTotalFrameSlotCount() : kElidedFrameSlots) - |
| StandardFrameConstants::kFixedSlotCountAboveFp; |
| return frame_slot_count + sp_delta(); |
| } |
| int GetSPToFPOffset() const { |
| return GetSPToFPSlotCount() * kSystemPointerSize; |
| } |
| |
| // 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: |
| const Frame* const frame_; |
| bool access_frame_with_fp_; |
| int sp_delta_; |
| bool has_frame_; |
| }; |
| } // namespace compiler |
| } // namespace internal |
| } // namespace v8 |
| |
| #endif // V8_COMPILER_FRAME_H_ |