/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/CodeGen/TargetFrameLowering.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===-- llvm/CodeGen/TargetFrameLowering.h ----------------------*- C++ -*-===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | // |
9 | | // Interface to describe the layout of a stack frame on the target machine. |
10 | | // |
11 | | //===----------------------------------------------------------------------===// |
12 | | |
13 | | #ifndef LLVM_CODEGEN_TARGETFRAMELOWERING_H |
14 | | #define LLVM_CODEGEN_TARGETFRAMELOWERING_H |
15 | | |
16 | | #include "llvm/CodeGen/MachineBasicBlock.h" |
17 | | #include "llvm/ADT/StringSwitch.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 | | namespace TargetStackID { |
28 | | enum Value { |
29 | | Default = 0, |
30 | | SGPRSpill = 1, |
31 | | NoAlloc = 255 |
32 | | }; |
33 | | } |
34 | | |
35 | | /// Information about stack frame layout on the target. It holds the direction |
36 | | /// of stack growth, the known stack alignment on entry to each function, and |
37 | | /// the offset to the locals area. |
38 | | /// |
39 | | /// The offset to the local area is the offset from the stack pointer on |
40 | | /// function entry to the first location where function data (local variables, |
41 | | /// spill locations) can be stored. |
42 | | class TargetFrameLowering { |
43 | | public: |
44 | | enum StackDirection { |
45 | | StackGrowsUp, // Adding to the stack increases the stack address |
46 | | StackGrowsDown // Adding to the stack decreases the stack address |
47 | | }; |
48 | | |
49 | | // Maps a callee saved register to a stack slot with a fixed offset. |
50 | | struct SpillSlot { |
51 | | unsigned Reg; |
52 | | int Offset; // Offset relative to stack pointer on function entry. |
53 | | }; |
54 | | private: |
55 | | StackDirection StackDir; |
56 | | unsigned StackAlignment; |
57 | | unsigned TransientStackAlignment; |
58 | | int LocalAreaOffset; |
59 | | bool StackRealignable; |
60 | | public: |
61 | | TargetFrameLowering(StackDirection D, unsigned StackAl, int LAO, |
62 | | unsigned TransAl = 1, bool StackReal = true) |
63 | | : StackDir(D), StackAlignment(StackAl), TransientStackAlignment(TransAl), |
64 | 53.2k | LocalAreaOffset(LAO), StackRealignable(StackReal) {} |
65 | | |
66 | | virtual ~TargetFrameLowering(); |
67 | | |
68 | | // These methods return information that describes the abstract stack layout |
69 | | // of the target machine. |
70 | | |
71 | | /// getStackGrowthDirection - Return the direction the stack grows |
72 | | /// |
73 | 663k | StackDirection getStackGrowthDirection() const { return StackDir; } |
74 | | |
75 | | /// getStackAlignment - This method returns the number of bytes to which the |
76 | | /// stack pointer must be aligned on entry to a function. Typically, this |
77 | | /// is the largest alignment for any data object in the target. |
78 | | /// |
79 | 14.1M | unsigned getStackAlignment() const { return StackAlignment; } |
80 | | |
81 | | /// alignSPAdjust - This method aligns the stack adjustment to the correct |
82 | | /// alignment. |
83 | | /// |
84 | 286 | int alignSPAdjust(int SPAdj) const { |
85 | 286 | if (SPAdj < 0) { |
86 | 0 | SPAdj = -alignTo(-SPAdj, StackAlignment); |
87 | 286 | } else { |
88 | 286 | SPAdj = alignTo(SPAdj, StackAlignment); |
89 | 286 | } |
90 | 286 | return SPAdj; |
91 | 286 | } |
92 | | |
93 | | /// getTransientStackAlignment - This method returns the number of bytes to |
94 | | /// which the stack pointer must be aligned at all times, even between |
95 | | /// calls. |
96 | | /// |
97 | 394k | unsigned getTransientStackAlignment() const { |
98 | 394k | return TransientStackAlignment; |
99 | 394k | } |
100 | | |
101 | | /// isStackRealignable - This method returns whether the stack can be |
102 | | /// realigned. |
103 | 574k | bool isStackRealignable() const { |
104 | 574k | return StackRealignable; |
105 | 574k | } |
106 | | |
107 | | /// Return the skew that has to be applied to stack alignment under |
108 | | /// certain conditions (e.g. stack was adjusted before function \p MF |
109 | | /// was called). |
110 | | virtual unsigned getStackAlignmentSkew(const MachineFunction &MF) const; |
111 | | |
112 | | /// getOffsetOfLocalArea - This method returns the offset of the local area |
113 | | /// from the stack pointer on entrance to a function. |
114 | | /// |
115 | 1.10M | int getOffsetOfLocalArea() const { return LocalAreaOffset; } |
116 | | |
117 | | /// isFPCloseToIncomingSP - Return true if the frame pointer is close to |
118 | | /// the incoming stack pointer, false if it is close to the post-prologue |
119 | | /// stack pointer. |
120 | 220k | virtual bool isFPCloseToIncomingSP() const { return true; } |
121 | | |
122 | | /// assignCalleeSavedSpillSlots - Allows target to override spill slot |
123 | | /// assignment logic. If implemented, assignCalleeSavedSpillSlots() should |
124 | | /// assign frame slots to all CSI entries and return true. If this method |
125 | | /// returns false, spill slots will be assigned using generic implementation. |
126 | | /// assignCalleeSavedSpillSlots() may add, delete or rearrange elements of |
127 | | /// CSI. |
128 | | virtual bool |
129 | | assignCalleeSavedSpillSlots(MachineFunction &MF, |
130 | | const TargetRegisterInfo *TRI, |
131 | 313k | std::vector<CalleeSavedInfo> &CSI) const { |
132 | 313k | return false; |
133 | 313k | } |
134 | | |
135 | | /// getCalleeSavedSpillSlots - This method returns a pointer to an array of |
136 | | /// pairs, that contains an entry for each callee saved register that must be |
137 | | /// spilled to a particular stack location if it is spilled. |
138 | | /// |
139 | | /// Each entry in this array contains a <register,offset> pair, indicating the |
140 | | /// fixed offset from the incoming stack pointer that each register should be |
141 | | /// spilled at. If a register is not listed here, the code generator is |
142 | | /// allowed to spill it anywhere it chooses. |
143 | | /// |
144 | | virtual const SpillSlot * |
145 | 207k | getCalleeSavedSpillSlots(unsigned &NumEntries) const { |
146 | 207k | NumEntries = 0; |
147 | 207k | return nullptr; |
148 | 207k | } |
149 | | |
150 | | /// targetHandlesStackFrameRounding - Returns true if the target is |
151 | | /// responsible for rounding up the stack frame (probably at emitPrologue |
152 | | /// time). |
153 | 481k | virtual bool targetHandlesStackFrameRounding() const { |
154 | 481k | return false; |
155 | 481k | } |
156 | | |
157 | | /// Returns true if the target will correctly handle shrink wrapping. |
158 | 43.7k | virtual bool enableShrinkWrapping(const MachineFunction &MF) const { |
159 | 43.7k | return false; |
160 | 43.7k | } |
161 | | |
162 | | /// Returns true if the stack slot holes in the fixed and callee-save stack |
163 | | /// area should be used when allocating other stack locations to reduce stack |
164 | | /// size. |
165 | 24.7k | virtual bool enableStackSlotScavenging(const MachineFunction &MF) const { |
166 | 24.7k | return false; |
167 | 24.7k | } |
168 | | |
169 | | /// Returns true if the target can safely skip saving callee-saved registers |
170 | | /// for noreturn nounwind functions. |
171 | | virtual bool enableCalleeSaveSkip(const MachineFunction &MF) const; |
172 | | |
173 | | /// emitProlog/emitEpilog - These methods insert prolog and epilog code into |
174 | | /// the function. |
175 | | virtual void emitPrologue(MachineFunction &MF, |
176 | | MachineBasicBlock &MBB) const = 0; |
177 | | virtual void emitEpilogue(MachineFunction &MF, |
178 | | MachineBasicBlock &MBB) const = 0; |
179 | | |
180 | | /// Replace a StackProbe stub (if any) with the actual probe code inline |
181 | | virtual void inlineStackProbe(MachineFunction &MF, |
182 | 359k | MachineBasicBlock &PrologueMBB) const {} |
183 | | |
184 | | /// Adjust the prologue to have the function use segmented stacks. This works |
185 | | /// by adding a check even before the "normal" function prologue. |
186 | | virtual void adjustForSegmentedStacks(MachineFunction &MF, |
187 | 0 | MachineBasicBlock &PrologueMBB) const {} |
188 | | |
189 | | /// Adjust the prologue to add Erlang Run-Time System (ERTS) specific code in |
190 | | /// the assembly prologue to explicitly handle the stack. |
191 | | virtual void adjustForHiPEPrologue(MachineFunction &MF, |
192 | 0 | MachineBasicBlock &PrologueMBB) const {} |
193 | | |
194 | | /// spillCalleeSavedRegisters - Issues instruction(s) to spill all callee |
195 | | /// saved registers and returns true if it isn't possible / profitable to do |
196 | | /// so by issuing a series of store instructions via |
197 | | /// storeRegToStackSlot(). Returns false otherwise. |
198 | | virtual bool spillCalleeSavedRegisters(MachineBasicBlock &MBB, |
199 | | MachineBasicBlock::iterator MI, |
200 | | const std::vector<CalleeSavedInfo> &CSI, |
201 | 1.46k | const TargetRegisterInfo *TRI) const { |
202 | 1.46k | return false; |
203 | 1.46k | } |
204 | | |
205 | | /// restoreCalleeSavedRegisters - Issues instruction(s) to restore all callee |
206 | | /// saved registers and returns true if it isn't possible / profitable to do |
207 | | /// so by issuing a series of load instructions via loadRegToStackSlot(). |
208 | | /// If it returns true, and any of the registers in CSI is not restored, |
209 | | /// it sets the corresponding Restored flag in CSI to false. |
210 | | /// Returns false otherwise. |
211 | | virtual bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB, |
212 | | MachineBasicBlock::iterator MI, |
213 | | std::vector<CalleeSavedInfo> &CSI, |
214 | 3.58k | const TargetRegisterInfo *TRI) const { |
215 | 3.58k | return false; |
216 | 3.58k | } |
217 | | |
218 | | /// Return true if the target wants to keep the frame pointer regardless of |
219 | | /// the function attribute "frame-pointer". |
220 | 16.6M | virtual bool keepFramePointer(const MachineFunction &MF) const { |
221 | 16.6M | return false; |
222 | 16.6M | } |
223 | | |
224 | | /// hasFP - Return true if the specified function should have a dedicated |
225 | | /// frame pointer register. For most targets this is true only if the function |
226 | | /// has variable sized allocas or if frame pointer elimination is disabled. |
227 | | virtual bool hasFP(const MachineFunction &MF) const = 0; |
228 | | |
229 | | /// hasReservedCallFrame - Under normal circumstances, when a frame pointer is |
230 | | /// not required, we reserve argument space for call sites in the function |
231 | | /// immediately on entry to the current function. This eliminates the need for |
232 | | /// add/sub sp brackets around call sites. Returns true if the call frame is |
233 | | /// included as part of the stack frame. |
234 | 8.41k | virtual bool hasReservedCallFrame(const MachineFunction &MF) const { |
235 | 8.41k | return !hasFP(MF); |
236 | 8.41k | } |
237 | | |
238 | | /// canSimplifyCallFramePseudos - When possible, it's best to simplify the |
239 | | /// call frame pseudo ops before doing frame index elimination. This is |
240 | | /// possible only when frame index references between the pseudos won't |
241 | | /// need adjusting for the call frame adjustments. Normally, that's true |
242 | | /// if the function has a reserved call frame or a frame pointer. Some |
243 | | /// targets (Thumb2, for example) may have more complicated criteria, |
244 | | /// however, and can override this behavior. |
245 | 2.51M | virtual bool canSimplifyCallFramePseudos(const MachineFunction &MF) const { |
246 | 2.51M | return hasReservedCallFrame(MF) || hasFP(MF)3.50k ; |
247 | 2.51M | } |
248 | | |
249 | | // needsFrameIndexResolution - Do we need to perform FI resolution for |
250 | | // this function. Normally, this is required only when the function |
251 | | // has any stack objects. However, targets may want to override this. |
252 | | virtual bool needsFrameIndexResolution(const MachineFunction &MF) const; |
253 | | |
254 | | /// getFrameIndexReference - This method should return the base register |
255 | | /// and offset used to reference a frame index location. The offset is |
256 | | /// returned directly, and the base register is returned via FrameReg. |
257 | | virtual int getFrameIndexReference(const MachineFunction &MF, int FI, |
258 | | unsigned &FrameReg) const; |
259 | | |
260 | | /// Same as \c getFrameIndexReference, except that the stack pointer (as |
261 | | /// opposed to the frame pointer) will be the preferred value for \p |
262 | | /// FrameReg. This is generally used for emitting statepoint or EH tables that |
263 | | /// use offsets from RSP. If \p IgnoreSPUpdates is true, the returned |
264 | | /// offset is only guaranteed to be valid with respect to the value of SP at |
265 | | /// the end of the prologue. |
266 | | virtual int getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI, |
267 | | unsigned &FrameReg, |
268 | 0 | bool IgnoreSPUpdates) const { |
269 | 0 | // Always safe to dispatch to getFrameIndexReference. |
270 | 0 | return getFrameIndexReference(MF, FI, FrameReg); |
271 | 0 | } |
272 | | |
273 | | /// getNonLocalFrameIndexReference - This method returns the offset used to |
274 | | /// reference a frame index location. The offset can be from either FP/BP/SP |
275 | | /// based on which base register is returned by llvm.localaddress. |
276 | | virtual int getNonLocalFrameIndexReference(const MachineFunction &MF, |
277 | 13 | int FI) const { |
278 | 13 | // By default, dispatch to getFrameIndexReference. Interested targets can |
279 | 13 | // override this. |
280 | 13 | unsigned FrameReg; |
281 | 13 | return getFrameIndexReference(MF, FI, FrameReg); |
282 | 13 | } |
283 | | |
284 | | /// This method determines which of the registers reported by |
285 | | /// TargetRegisterInfo::getCalleeSavedRegs() should actually get saved. |
286 | | /// The default implementation checks populates the \p SavedRegs bitset with |
287 | | /// all registers which are modified in the function, targets may override |
288 | | /// this function to save additional registers. |
289 | | /// This method also sets up the register scavenger ensuring there is a free |
290 | | /// register or a frameindex available. |
291 | | virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, |
292 | | RegScavenger *RS = nullptr) const; |
293 | | |
294 | | /// processFunctionBeforeFrameFinalized - This method is called immediately |
295 | | /// before the specified function's frame layout (MF.getFrameInfo()) is |
296 | | /// finalized. Once the frame is finalized, MO_FrameIndex operands are |
297 | | /// replaced with direct constants. This method is optional. |
298 | | /// |
299 | | virtual void processFunctionBeforeFrameFinalized(MachineFunction &MF, |
300 | 47.5k | RegScavenger *RS = nullptr) const { |
301 | 47.5k | } |
302 | | |
303 | 0 | virtual unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const { |
304 | 0 | report_fatal_error("WinEH not implemented for this target"); |
305 | 0 | } |
306 | | |
307 | | /// This method is called during prolog/epilog code insertion to eliminate |
308 | | /// call frame setup and destroy pseudo instructions (but only if the Target |
309 | | /// is using them). It is responsible for eliminating these instructions, |
310 | | /// replacing them with concrete instructions. This method need only be |
311 | | /// implemented if using call frame setup/destroy pseudo instructions. |
312 | | /// Returns an iterator pointing to the instruction after the replaced one. |
313 | | virtual MachineBasicBlock::iterator |
314 | | eliminateCallFramePseudoInstr(MachineFunction &MF, |
315 | | MachineBasicBlock &MBB, |
316 | 0 | MachineBasicBlock::iterator MI) const { |
317 | 0 | llvm_unreachable("Call Frame Pseudo Instructions do not exist on this " |
318 | 0 | "target!"); |
319 | 0 | } |
320 | | |
321 | | |
322 | | /// Order the symbols in the local stack frame. |
323 | | /// The list of objects that we want to order is in \p objectsToAllocate as |
324 | | /// indices into the MachineFrameInfo. The array can be reordered in any way |
325 | | /// upon return. The contents of the array, however, may not be modified (i.e. |
326 | | /// only their order may be changed). |
327 | | /// By default, just maintain the original order. |
328 | | virtual void |
329 | | orderFrameObjects(const MachineFunction &MF, |
330 | 353k | SmallVectorImpl<int> &objectsToAllocate) const { |
331 | 353k | } |
332 | | |
333 | | /// Check whether or not the given \p MBB can be used as a prologue |
334 | | /// for the target. |
335 | | /// The prologue will be inserted first in this basic block. |
336 | | /// This method is used by the shrink-wrapping pass to decide if |
337 | | /// \p MBB will be correctly handled by the target. |
338 | | /// As soon as the target enable shrink-wrapping without overriding |
339 | | /// this method, we assume that each basic block is a valid |
340 | | /// prologue. |
341 | 415 | virtual bool canUseAsPrologue(const MachineBasicBlock &MBB) const { |
342 | 415 | return true; |
343 | 415 | } |
344 | | |
345 | | /// Check whether or not the given \p MBB can be used as a epilogue |
346 | | /// for the target. |
347 | | /// The epilogue will be inserted before the first terminator of that block. |
348 | | /// This method is used by the shrink-wrapping pass to decide if |
349 | | /// \p MBB will be correctly handled by the target. |
350 | | /// As soon as the target enable shrink-wrapping without overriding |
351 | | /// this method, we assume that each basic block is a valid |
352 | | /// epilogue. |
353 | 4.01k | virtual bool canUseAsEpilogue(const MachineBasicBlock &MBB) const { |
354 | 4.01k | return true; |
355 | 4.01k | } |
356 | | |
357 | 769 | virtual bool isSupportedStackID(TargetStackID::Value ID) const { |
358 | 769 | switch (ID) { |
359 | 769 | default: |
360 | 0 | return false; |
361 | 769 | case TargetStackID::Default: |
362 | 769 | case TargetStackID::NoAlloc: |
363 | 769 | return true; |
364 | 769 | } |
365 | 769 | } |
366 | | |
367 | | /// Check if given function is safe for not having callee saved registers. |
368 | | /// This is used when interprocedural register allocation is enabled. |
369 | 50.4k | static bool isSafeForNoCSROpt(const Function &F) { |
370 | 50.4k | if (!F.hasLocalLinkage() || F.hasAddressTaken()27 || |
371 | 50.4k | !F.hasFnAttribute(Attribute::NoRecurse)27 ) |
372 | 50.4k | return false; |
373 | 3 | // Function should not be optimized as tail call. |
374 | 3 | for (const User *U : F.users()) |
375 | 3 | if (auto CS = ImmutableCallSite(U)) |
376 | 3 | if (CS.isTailCall()) |
377 | 0 | return false; |
378 | 3 | return true; |
379 | 3 | } |
380 | | |
381 | | /// Return initial CFA offset value i.e. the one valid at the beginning of the |
382 | | /// function (before any stack operations). |
383 | | virtual int getInitialCFAOffset(const MachineFunction &MF) const; |
384 | | |
385 | | /// Return initial CFA register value i.e. the one valid at the beginning of |
386 | | /// the function (before any stack operations). |
387 | | virtual unsigned getInitialCFARegister(const MachineFunction &MF) const; |
388 | | }; |
389 | | |
390 | | } // End llvm namespace |
391 | | |
392 | | #endif |