Taints the non-acquire RMW's store address with the load part
[oota-llvm.git] / include / llvm / Target / TargetFrameLowering.h
1 //===-- llvm/Target/TargetFrameLowering.h ---------------------------*- C++ -*-===//
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 // Interface to describe the layout of a stack frame on the target machine.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #ifndef LLVM_TARGET_TARGETFRAMELOWERING_H
15 #define LLVM_TARGET_TARGETFRAMELOWERING_H
16
17 #include "llvm/CodeGen/MachineBasicBlock.h"
18 #include <utility>
19 #include <vector>
20
21 namespace llvm {
22   class BitVector;
23   class CalleeSavedInfo;
24   class MachineFunction;
25   class RegScavenger;
26
27 /// Information about stack frame layout on the target.  It holds the direction
28 /// of stack growth, the known stack alignment on entry to each function, and
29 /// the offset to the locals area.
30 ///
31 /// The offset to the local area is the offset from the stack pointer on
32 /// function entry to the first location where function data (local variables,
33 /// spill locations) can be stored.
34 class TargetFrameLowering {
35 public:
36   enum StackDirection {
37     StackGrowsUp,        // Adding to the stack increases the stack address
38     StackGrowsDown       // Adding to the stack decreases the stack address
39   };
40
41   // Maps a callee saved register to a stack slot with a fixed offset.
42   struct SpillSlot {
43     unsigned Reg;
44     int Offset; // Offset relative to stack pointer on function entry.
45   };
46 private:
47   StackDirection StackDir;
48   unsigned StackAlignment;
49   unsigned TransientStackAlignment;
50   int LocalAreaOffset;
51   bool StackRealignable;
52 public:
53   TargetFrameLowering(StackDirection D, unsigned StackAl, int LAO,
54                       unsigned TransAl = 1, bool StackReal = true)
55     : StackDir(D), StackAlignment(StackAl), TransientStackAlignment(TransAl),
56       LocalAreaOffset(LAO), StackRealignable(StackReal) {}
57
58   virtual ~TargetFrameLowering();
59
60   // These methods return information that describes the abstract stack layout
61   // of the target machine.
62
63   /// getStackGrowthDirection - Return the direction the stack grows
64   ///
65   StackDirection getStackGrowthDirection() const { return StackDir; }
66
67   /// getStackAlignment - This method returns the number of bytes to which the
68   /// stack pointer must be aligned on entry to a function.  Typically, this
69   /// is the largest alignment for any data object in the target.
70   ///
71   unsigned getStackAlignment() const { return StackAlignment; }
72
73   /// alignSPAdjust - This method aligns the stack adjustment to the correct
74   /// alignment.
75   ///
76   int alignSPAdjust(int SPAdj) const {
77     if (SPAdj < 0) {
78       SPAdj = -RoundUpToAlignment(-SPAdj, StackAlignment);
79     } else {
80       SPAdj = RoundUpToAlignment(SPAdj, StackAlignment);
81     }
82     return SPAdj;
83   }
84
85   /// getTransientStackAlignment - This method returns the number of bytes to
86   /// which the stack pointer must be aligned at all times, even between
87   /// calls.
88   ///
89   unsigned getTransientStackAlignment() const {
90     return TransientStackAlignment;
91   }
92
93   /// isStackRealignable - This method returns whether the stack can be
94   /// realigned.
95   bool isStackRealignable() const {
96     return StackRealignable;
97   }
98
99   /// Return the skew that has to be applied to stack alignment under
100   /// certain conditions (e.g. stack was adjusted before function \p MF
101   /// was called).
102   virtual unsigned getStackAlignmentSkew(const MachineFunction &MF) const;
103
104   /// getOffsetOfLocalArea - This method returns the offset of the local area
105   /// from the stack pointer on entrance to a function.
106   ///
107   int getOffsetOfLocalArea() const { return LocalAreaOffset; }
108
109   /// isFPCloseToIncomingSP - Return true if the frame pointer is close to
110   /// the incoming stack pointer, false if it is close to the post-prologue
111   /// stack pointer.
112   virtual bool isFPCloseToIncomingSP() const { return true; }
113
114   /// assignCalleeSavedSpillSlots - Allows target to override spill slot
115   /// assignment logic.  If implemented, assignCalleeSavedSpillSlots() should
116   /// assign frame slots to all CSI entries and return true.  If this method
117   /// returns false, spill slots will be assigned using generic implementation.
118   /// assignCalleeSavedSpillSlots() may add, delete or rearrange elements of
119   /// CSI.
120   virtual bool
121   assignCalleeSavedSpillSlots(MachineFunction &MF,
122                               const TargetRegisterInfo *TRI,
123                               std::vector<CalleeSavedInfo> &CSI) const {
124     return false;
125   }
126
127   /// getCalleeSavedSpillSlots - This method returns a pointer to an array of
128   /// pairs, that contains an entry for each callee saved register that must be
129   /// spilled to a particular stack location if it is spilled.
130   ///
131   /// Each entry in this array contains a <register,offset> pair, indicating the
132   /// fixed offset from the incoming stack pointer that each register should be
133   /// spilled at. If a register is not listed here, the code generator is
134   /// allowed to spill it anywhere it chooses.
135   ///
136   virtual const SpillSlot *
137   getCalleeSavedSpillSlots(unsigned &NumEntries) const {
138     NumEntries = 0;
139     return nullptr;
140   }
141
142   /// targetHandlesStackFrameRounding - Returns true if the target is
143   /// responsible for rounding up the stack frame (probably at emitPrologue
144   /// time).
145   virtual bool targetHandlesStackFrameRounding() const {
146     return false;
147   }
148
149   /// Returns true if the target will correctly handle shrink wrapping.
150   virtual bool enableShrinkWrapping(const MachineFunction &MF) const {
151     return false;
152   }
153
154   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
155   /// the function.
156   virtual void emitPrologue(MachineFunction &MF,
157                             MachineBasicBlock &MBB) const = 0;
158   virtual void emitEpilogue(MachineFunction &MF,
159                             MachineBasicBlock &MBB) const = 0;
160
161   /// Replace a StackProbe stub (if any) with the actual probe code inline
162   virtual void inlineStackProbe(MachineFunction &MF,
163                                 MachineBasicBlock &PrologueMBB) const {}
164
165   /// Adjust the prologue to have the function use segmented stacks. This works
166   /// by adding a check even before the "normal" function prologue.
167   virtual void adjustForSegmentedStacks(MachineFunction &MF,
168                                         MachineBasicBlock &PrologueMBB) const {}
169
170   /// Adjust the prologue to add Erlang Run-Time System (ERTS) specific code in
171   /// the assembly prologue to explicitly handle the stack.
172   virtual void adjustForHiPEPrologue(MachineFunction &MF,
173                                      MachineBasicBlock &PrologueMBB) const {}
174
175   /// Adjust the prologue to add an allocation at a fixed offset from the frame
176   /// pointer.
177   virtual void
178   adjustForFrameAllocatePrologue(MachineFunction &MF,
179                                  MachineBasicBlock &PrologueMBB) const {}
180
181   /// spillCalleeSavedRegisters - Issues instruction(s) to spill all callee
182   /// saved registers and returns true if it isn't possible / profitable to do
183   /// so by issuing a series of store instructions via
184   /// storeRegToStackSlot(). Returns false otherwise.
185   virtual bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
186                                          MachineBasicBlock::iterator MI,
187                                         const std::vector<CalleeSavedInfo> &CSI,
188                                          const TargetRegisterInfo *TRI) const {
189     return false;
190   }
191
192   /// restoreCalleeSavedRegisters - Issues instruction(s) to restore all callee
193   /// saved registers and returns true if it isn't possible / profitable to do
194   /// so by issuing a series of load instructions via loadRegToStackSlot().
195   /// Returns false otherwise.
196   virtual bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
197                                            MachineBasicBlock::iterator MI,
198                                         const std::vector<CalleeSavedInfo> &CSI,
199                                         const TargetRegisterInfo *TRI) const {
200     return false;
201   }
202
203   /// Return true if the target needs to disable frame pointer elimination.
204   virtual bool noFramePointerElim(const MachineFunction &MF) const;
205
206   /// hasFP - Return true if the specified function should have a dedicated
207   /// frame pointer register. For most targets this is true only if the function
208   /// has variable sized allocas or if frame pointer elimination is disabled.
209   virtual bool hasFP(const MachineFunction &MF) const = 0;
210
211   /// hasReservedCallFrame - Under normal circumstances, when a frame pointer is
212   /// not required, we reserve argument space for call sites in the function
213   /// immediately on entry to the current function. This eliminates the need for
214   /// add/sub sp brackets around call sites. Returns true if the call frame is
215   /// included as part of the stack frame.
216   virtual bool hasReservedCallFrame(const MachineFunction &MF) const {
217     return !hasFP(MF);
218   }
219
220   /// canSimplifyCallFramePseudos - When possible, it's best to simplify the
221   /// call frame pseudo ops before doing frame index elimination. This is
222   /// possible only when frame index references between the pseudos won't
223   /// need adjusting for the call frame adjustments. Normally, that's true
224   /// if the function has a reserved call frame or a frame pointer. Some
225   /// targets (Thumb2, for example) may have more complicated criteria,
226   /// however, and can override this behavior.
227   virtual bool canSimplifyCallFramePseudos(const MachineFunction &MF) const {
228     return hasReservedCallFrame(MF) || hasFP(MF);
229   }
230
231   // needsFrameIndexResolution - Do we need to perform FI resolution for
232   // this function. Normally, this is required only when the function
233   // has any stack objects. However, targets may want to override this.
234   virtual bool needsFrameIndexResolution(const MachineFunction &MF) const;
235
236   /// getFrameIndexReference - This method should return the base register
237   /// and offset used to reference a frame index location. The offset is
238   /// returned directly, and the base register is returned via FrameReg.
239   virtual int getFrameIndexReference(const MachineFunction &MF, int FI,
240                                      unsigned &FrameReg) const;
241
242   /// Same as above, except that the 'base register' will always be RSP, not
243   /// RBP on x86. This is generally used for emitting statepoint or EH tables
244   /// that use offsets from RSP.
245   /// TODO: This should really be a parameterizable choice.
246   virtual int getFrameIndexReferenceFromSP(const MachineFunction &MF, int FI,
247                                            unsigned &FrameReg) const {
248     // default to calling normal version, we override this on x86 only
249     llvm_unreachable("unimplemented for non-x86");
250     return 0;
251   }
252
253   /// This method determines which of the registers reported by
254   /// TargetRegisterInfo::getCalleeSavedRegs() should actually get saved.
255   /// The default implementation checks populates the \p SavedRegs bitset with
256   /// all registers which are modified in the function, targets may override
257   /// this function to save additional registers.
258   /// This method also sets up the register scavenger ensuring there is a free
259   /// register or a frameindex available.
260   virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
261                                     RegScavenger *RS = nullptr) const;
262
263   /// processFunctionBeforeFrameFinalized - This method is called immediately
264   /// before the specified function's frame layout (MF.getFrameInfo()) is
265   /// finalized.  Once the frame is finalized, MO_FrameIndex operands are
266   /// replaced with direct constants.  This method is optional.
267   ///
268   virtual void processFunctionBeforeFrameFinalized(MachineFunction &MF,
269                                              RegScavenger *RS = nullptr) const {
270   }
271
272   virtual unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const {
273     report_fatal_error("WinEH not implemented for this target");
274   }
275
276   /// eliminateCallFramePseudoInstr - This method is called during prolog/epilog
277   /// code insertion to eliminate call frame setup and destroy pseudo
278   /// instructions (but only if the Target is using them).  It is responsible
279   /// for eliminating these instructions, replacing them with concrete
280   /// instructions.  This method need only be implemented if using call frame
281   /// setup/destroy pseudo instructions.
282   ///
283   virtual void
284   eliminateCallFramePseudoInstr(MachineFunction &MF,
285                                 MachineBasicBlock &MBB,
286                                 MachineBasicBlock::iterator MI) const {
287     llvm_unreachable("Call Frame Pseudo Instructions do not exist on this "
288                      "target!");
289   }
290
291   /// Check whether or not the given \p MBB can be used as a prologue
292   /// for the target.
293   /// The prologue will be inserted first in this basic block.
294   /// This method is used by the shrink-wrapping pass to decide if
295   /// \p MBB will be correctly handled by the target.
296   /// As soon as the target enable shrink-wrapping without overriding
297   /// this method, we assume that each basic block is a valid
298   /// prologue.
299   virtual bool canUseAsPrologue(const MachineBasicBlock &MBB) const {
300     return true;
301   }
302
303   /// Check whether or not the given \p MBB can be used as a epilogue
304   /// for the target.
305   /// The epilogue will be inserted before the first terminator of that block.
306   /// This method is used by the shrink-wrapping pass to decide if
307   /// \p MBB will be correctly handled by the target.
308   /// As soon as the target enable shrink-wrapping without overriding
309   /// this method, we assume that each basic block is a valid
310   /// epilogue.
311   virtual bool canUseAsEpilogue(const MachineBasicBlock &MBB) const {
312     return true;
313   }
314 };
315
316 } // End llvm namespace
317
318 #endif