LLVM  3.7.0
MipsFrameLowering.cpp
Go to the documentation of this file.
1 //===-- MipsFrameLowering.cpp - Mips Frame Information --------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains the Mips implementation of TargetFrameLowering class.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "MipsFrameLowering.h"
16 #include "MipsAnalyzeImmediate.h"
17 #include "MipsInstrInfo.h"
18 #include "MipsMachineFunction.h"
19 #include "MipsTargetMachine.h"
25 #include "llvm/IR/DataLayout.h"
26 #include "llvm/IR/Function.h"
29 
30 using namespace llvm;
31 
32 
33 //===----------------------------------------------------------------------===//
34 //
35 // Stack Frame Processing methods
36 // +----------------------------+
37 //
38 // The stack is allocated decrementing the stack pointer on
39 // the first instruction of a function prologue. Once decremented,
40 // all stack references are done thought a positive offset
41 // from the stack/frame pointer, so the stack is considering
42 // to grow up! Otherwise terrible hacks would have to be made
43 // to get this stack ABI compliant :)
44 //
45 // The stack frame required by the ABI (after call):
46 // Offset
47 //
48 // 0 ----------
49 // 4 Args to pass
50 // . saved $GP (used in PIC)
51 // . Alloca allocations
52 // . Local Area
53 // . CPU "Callee Saved" Registers
54 // . saved FP
55 // . saved RA
56 // . FPU "Callee Saved" Registers
57 // StackSize -----------
58 //
59 // Offset - offset from sp after stack allocation on function prologue
60 //
61 // The sp is the stack pointer subtracted/added from the stack size
62 // at the Prologue/Epilogue
63 //
64 // References to the previous stack (to obtain arguments) are done
65 // with offsets that exceeds the stack size: (stacksize+(4*(num_arg-1))
66 //
67 // Examples:
68 // - reference to the actual stack frame
69 // for any local area var there is smt like : FI >= 0, StackOffset: 4
70 // sw REGX, 4(SP)
71 //
72 // - reference to previous stack frame
73 // suppose there's a load to the 5th arguments : FI < 0, StackOffset: 16.
74 // The emitted instruction will be something like:
75 // lw REGX, 16+StackSize(SP)
76 //
77 // Since the total stack size is unknown on LowerFormalArguments, all
78 // stack references (ObjectOffset) created to reference the function
79 // arguments, are negative numbers. This way, on eliminateFrameIndex it's
80 // possible to detect those references and the offsets are adjusted to
81 // their real location.
82 //
83 //===----------------------------------------------------------------------===//
84 
86  if (ST.inMips16Mode())
88 
90 }
91 
92 // hasFP - Return true if the specified function should have a dedicated frame
93 // pointer register. This is true if the function has variable sized allocas,
94 // if it needs dynamic stack realignment, if frame pointer elimination is
95 // disabled, or if the frame address is taken.
97  const MachineFrameInfo *MFI = MF.getFrameInfo();
98  const TargetRegisterInfo *TRI = STI.getRegisterInfo();
99 
100  return MF.getTarget().Options.DisableFramePointerElim(MF) ||
101  MFI->hasVarSizedObjects() || MFI->isFrameAddressTaken() ||
102  TRI->needsStackRealignment(MF);
103 }
104 
106  const MachineFrameInfo *MFI = MF.getFrameInfo();
107  const TargetRegisterInfo *TRI = STI.getRegisterInfo();
108 
109  return MFI->hasVarSizedObjects() && TRI->needsStackRealignment(MF);
110 }
111 
113  const MachineFrameInfo *MFI = MF.getFrameInfo();
114  const TargetRegisterInfo &TRI = *STI.getRegisterInfo();
115 
116  int64_t Offset = 0;
117 
118  // Iterate over fixed sized objects.
119  for (int I = MFI->getObjectIndexBegin(); I != 0; ++I)
120  Offset = std::max(Offset, -MFI->getObjectOffset(I));
121 
122  // Conservatively assume all callee-saved registers will be saved.
123  for (const MCPhysReg *R = TRI.getCalleeSavedRegs(&MF); *R; ++R) {
124  unsigned Size = TRI.getMinimalPhysRegClass(*R)->getSize();
125  Offset = RoundUpToAlignment(Offset + Size, Size);
126  }
127 
128  unsigned MaxAlign = MFI->getMaxAlignment();
129 
130  // Check that MaxAlign is not zero if there is a stack object that is not a
131  // callee-saved spill.
132  assert(!MFI->getObjectIndexEnd() || MaxAlign);
133 
134  // Iterate over other objects.
135  for (unsigned I = 0, E = MFI->getObjectIndexEnd(); I != E; ++I)
136  Offset = RoundUpToAlignment(Offset + MFI->getObjectSize(I), MaxAlign);
137 
138  // Call frame.
139  if (MFI->adjustsStack() && hasReservedCallFrame(MF))
140  Offset = RoundUpToAlignment(Offset + MFI->getMaxCallFrameSize(),
141  std::max(MaxAlign, getStackAlignment()));
142 
143  return RoundUpToAlignment(Offset, getStackAlignment());
144 }
145 
146 // Eliminate ADJCALLSTACKDOWN, ADJCALLSTACKUP pseudo instructions
150  unsigned SP = STI.getABI().IsN64() ? Mips::SP_64 : Mips::SP;
151 
152  if (!hasReservedCallFrame(MF)) {
153  int64_t Amount = I->getOperand(0).getImm();
154  if (I->getOpcode() == Mips::ADJCALLSTACKDOWN)
155  Amount = -Amount;
156 
157  STI.getInstrInfo()->adjustStackPtr(SP, Amount, MBB, I);
158  }
159 
160  MBB.erase(I);
161 }
unsigned getStackAlignment() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
const MipsFrameLowering * createMipsSEFrameLowering(const MipsSubtarget &ST)
const MipsABIInfo & getABI() const
const MipsFrameLowering * createMips16FrameLowering(const MipsSubtarget &ST)
Create MipsFrameLowering objects.
const MipsSubtarget & STI
const MipsInstrInfo * getInstrInfo() const override
bool adjustsStack() const
Return true if this function adjusts the stack – e.g., when calling another function.
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
static const MipsFrameLowering * create(const MipsSubtarget &ST)
unsigned getMaxAlignment() const
Return the alignment in bytes that this function must be aligned to, which is greater than the defaul...
unsigned getSize() const
getSize - Return the size of the register in bytes, which is also the size of a stack slot allocated ...
instr_iterator erase(instr_iterator I)
Remove an instruction from the instruction list and delete it.
bool DisableFramePointerElim(const MachineFunction &MF) const
DisableFramePointerElim - This returns true if frame pointer elimination optimization should be disab...
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
bool isFrameAddressTaken() const
This method may be called any time after instruction selection is complete to determine if there is a...
bool hasFP(const MachineFunction &MF) const override
hasFP - Return true if the specified function should have a dedicated frame pointer register...
int getObjectIndexBegin() const
Return the minimum frame object index.
bool hasBP(const MachineFunction &MF) const
virtual const MCPhysReg * getCalleeSavedRegs(const MachineFunction *MF) const =0
getCalleeSavedRegs - Return a null-terminated list of all of the callee saved registers on this targe...
bundle_iterator< MachineInstr, instr_iterator > iterator
virtual bool needsStackRealignment(const MachineFunction &MF) const
needsStackRealignment - true if storage within the function requires the stack pointer to be aligned ...
bool IsN64() const
Definition: MipsABIInfo.h:45
bool inMips16Mode() const
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
virtual bool hasReservedCallFrame(const MachineFunction &MF) const
hasReservedCallFrame - Under normal circumstances, when a frame pointer is not required, we reserve argument space for call sites in the function immediately on entry to the current function.
int64_t getObjectOffset(int ObjectIdx) const
Return the assigned stack offset of the specified object from the incoming stack pointer.
const MipsRegisterInfo * getRegisterInfo() const override
unsigned getMaxCallFrameSize() const
Return the maximum size of a call frame that must be allocated for an outgoing function call...
MachineFrameInfo * getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
void eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const override
eliminateCallFramePseudoInstr - This method is called during prolog/epilog code insertion to eliminat...
const TargetRegisterClass * getMinimalPhysRegClass(unsigned Reg, MVT VT=MVT::Other) const
getMinimalPhysRegClass - Returns the Register Class of a physical register of the given type...
uint64_t RoundUpToAlignment(uint64_t Value, uint64_t Align)
Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Alig...
Definition: MathExtras.h:609
#define I(x, y, z)
Definition: MD5.cpp:54
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
bool hasVarSizedObjects() const
This method may be called any time after instruction selection is complete to determine if the stack ...
uint64_t estimateStackSize(const MachineFunction &MF) const
int getObjectIndexEnd() const
Return one past the maximum frame object index.
int64_t getObjectSize(int ObjectIdx) const
Return the size of the specified object.
virtual void adjustStackPtr(unsigned SP, int64_t Amount, MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const =0