Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/Target/TargetFrameLowering.h
Line
Count
Source (jump to first uncovered line)
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
44.6k
      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
685k
  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
9.45M
  unsigned getStackAlignment() const { return StackAlignment; }
72
73
  /// alignSPAdjust - This method aligns the stack adjustment to the correct
74
  /// alignment.
75
  ///
76
160
  int alignSPAdjust(int SPAdj) const {
77
160
    if (
SPAdj < 0160
) {
78
0
      SPAdj = -alignTo(-SPAdj, StackAlignment);
79
160
    } else {
80
160
      SPAdj = alignTo(SPAdj, StackAlignment);
81
160
    }
82
160
    return SPAdj;
83
160
  }
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
551k
  unsigned getTransientStackAlignment() const {
90
551k
    return TransientStackAlignment;
91
551k
  }
92
93
  /// isStackRealignable - This method returns whether the stack can be
94
  /// realigned.
95
747k
  bool isStackRealignable() const {
96
747k
    return StackRealignable;
97
747k
  }
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
990k
  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
315k
  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
518k
                              std::vector<CalleeSavedInfo> &CSI) const {
124
518k
    return false;
125
518k
  }
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
319k
  getCalleeSavedSpillSlots(unsigned &NumEntries) const {
138
319k
    NumEntries = 0;
139
319k
    return nullptr;
140
319k
  }
141
142
  /// targetHandlesStackFrameRounding - Returns true if the target is
143
  /// responsible for rounding up the stack frame (probably at emitPrologue
144
  /// time).
145
585k
  virtual bool targetHandlesStackFrameRounding() const {
146
585k
    return false;
147
585k
  }
148
149
  /// Returns true if the target will correctly handle shrink wrapping.
150
38.5k
  virtual bool enableShrinkWrapping(const MachineFunction &MF) const {
151
38.5k
    return false;
152
38.5k
  }
153
154
  /// Returns true if the stack slot holes in the fixed and callee-save stack
155
  /// area should be used when allocating other stack locations to reduce stack
156
  /// size.
157
11.9k
  virtual bool enableStackSlotScavenging(const MachineFunction &MF) const {
158
11.9k
    return false;
159
11.9k
  }
160
161
  /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
162
  /// the function.
163
  virtual void emitPrologue(MachineFunction &MF,
164
                            MachineBasicBlock &MBB) const = 0;
165
  virtual void emitEpilogue(MachineFunction &MF,
166
                            MachineBasicBlock &MBB) const = 0;
167
168
  /// Replace a StackProbe stub (if any) with the actual probe code inline
169
  virtual void inlineStackProbe(MachineFunction &MF,
170
521k
                                MachineBasicBlock &PrologueMBB) const {}
171
172
  /// Adjust the prologue to have the function use segmented stacks. This works
173
  /// by adding a check even before the "normal" function prologue.
174
  virtual void adjustForSegmentedStacks(MachineFunction &MF,
175
0
                                        MachineBasicBlock &PrologueMBB) const {}
176
177
  /// Adjust the prologue to add Erlang Run-Time System (ERTS) specific code in
178
  /// the assembly prologue to explicitly handle the stack.
179
  virtual void adjustForHiPEPrologue(MachineFunction &MF,
180
0
                                     MachineBasicBlock &PrologueMBB) const {}
181
182
  /// spillCalleeSavedRegisters - Issues instruction(s) to spill all callee
183
  /// saved registers and returns true if it isn't possible / profitable to do
184
  /// so by issuing a series of store instructions via
185
  /// storeRegToStackSlot(). Returns false otherwise.
186
  virtual bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
187
                                         MachineBasicBlock::iterator MI,
188
                                        const std::vector<CalleeSavedInfo> &CSI,
189
108
                                         const TargetRegisterInfo *TRI) const {
190
108
    return false;
191
108
  }
192
193
  /// restoreCalleeSavedRegisters - Issues instruction(s) to restore all callee
194
  /// saved registers and returns true if it isn't possible / profitable to do
195
  /// so by issuing a series of load instructions via loadRegToStackSlot().
196
  /// If it returns true, and any of the registers in CSI is not restored,
197
  /// it sets the corresponding Restored flag in CSI to false.
198
  /// Returns false otherwise.
199
  virtual bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
200
                                           MachineBasicBlock::iterator MI,
201
                                           std::vector<CalleeSavedInfo> &CSI,
202
2.00k
                                        const TargetRegisterInfo *TRI) const {
203
2.00k
    return false;
204
2.00k
  }
205
206
  /// Return true if the target needs to disable frame pointer elimination.
207
  virtual bool noFramePointerElim(const MachineFunction &MF) const;
208
209
  /// hasFP - Return true if the specified function should have a dedicated
210
  /// frame pointer register. For most targets this is true only if the function
211
  /// has variable sized allocas or if frame pointer elimination is disabled.
212
  virtual bool hasFP(const MachineFunction &MF) const = 0;
213
214
  /// hasReservedCallFrame - Under normal circumstances, when a frame pointer is
215
  /// not required, we reserve argument space for call sites in the function
216
  /// immediately on entry to the current function. This eliminates the need for
217
  /// add/sub sp brackets around call sites. Returns true if the call frame is
218
  /// included as part of the stack frame.
219
5.95k
  virtual bool hasReservedCallFrame(const MachineFunction &MF) const {
220
5.95k
    return !hasFP(MF);
221
5.95k
  }
222
223
  /// canSimplifyCallFramePseudos - When possible, it's best to simplify the
224
  /// call frame pseudo ops before doing frame index elimination. This is
225
  /// possible only when frame index references between the pseudos won't
226
  /// need adjusting for the call frame adjustments. Normally, that's true
227
  /// if the function has a reserved call frame or a frame pointer. Some
228
  /// targets (Thumb2, for example) may have more complicated criteria,
229
  /// however, and can override this behavior.
230
4.20M
  virtual bool canSimplifyCallFramePseudos(const MachineFunction &MF) const {
231
3.66k
    return hasReservedCallFrame(MF) || hasFP(MF);
232
4.20M
  }
233
234
  // needsFrameIndexResolution - Do we need to perform FI resolution for
235
  // this function. Normally, this is required only when the function
236
  // has any stack objects. However, targets may want to override this.
237
  virtual bool needsFrameIndexResolution(const MachineFunction &MF) const;
238
239
  /// getFrameIndexReference - This method should return the base register
240
  /// and offset used to reference a frame index location. The offset is
241
  /// returned directly, and the base register is returned via FrameReg.
242
  virtual int getFrameIndexReference(const MachineFunction &MF, int FI,
243
                                     unsigned &FrameReg) const;
244
245
  /// Same as \c getFrameIndexReference, except that the stack pointer (as
246
  /// opposed to the frame pointer) will be the preferred value for \p
247
  /// FrameReg. This is generally used for emitting statepoint or EH tables that
248
  /// use offsets from RSP.  If \p IgnoreSPUpdates is true, the returned
249
  /// offset is only guaranteed to be valid with respect to the value of SP at
250
  /// the end of the prologue.
251
  virtual int getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI,
252
                                             unsigned &FrameReg,
253
0
                                             bool IgnoreSPUpdates) const {
254
0
    // Always safe to dispatch to getFrameIndexReference.
255
0
    return getFrameIndexReference(MF, FI, FrameReg);
256
0
  }
257
258
  /// This method determines which of the registers reported by
259
  /// TargetRegisterInfo::getCalleeSavedRegs() should actually get saved.
260
  /// The default implementation checks populates the \p SavedRegs bitset with
261
  /// all registers which are modified in the function, targets may override
262
  /// this function to save additional registers.
263
  /// This method also sets up the register scavenger ensuring there is a free
264
  /// register or a frameindex available.
265
  virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
266
                                    RegScavenger *RS = nullptr) const;
267
268
  /// processFunctionBeforeFrameFinalized - This method is called immediately
269
  /// before the specified function's frame layout (MF.getFrameInfo()) is
270
  /// finalized.  Once the frame is finalized, MO_FrameIndex operands are
271
  /// replaced with direct constants.  This method is optional.
272
  ///
273
  virtual void processFunctionBeforeFrameFinalized(MachineFunction &MF,
274
489k
                                             RegScavenger *RS = nullptr) const {
275
489k
  }
276
277
0
  virtual unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const {
278
0
    report_fatal_error("WinEH not implemented for this target");
279
0
  }
280
281
  /// This method is called during prolog/epilog code insertion to eliminate
282
  /// call frame setup and destroy pseudo instructions (but only if the Target
283
  /// is using them).  It is responsible for eliminating these instructions,
284
  /// replacing them with concrete instructions.  This method need only be
285
  /// implemented if using call frame setup/destroy pseudo instructions.
286
  /// Returns an iterator pointing to the instruction after the replaced one.
287
  virtual MachineBasicBlock::iterator
288
  eliminateCallFramePseudoInstr(MachineFunction &MF,
289
                                MachineBasicBlock &MBB,
290
0
                                MachineBasicBlock::iterator MI) const {
291
0
    llvm_unreachable("Call Frame Pseudo Instructions do not exist on this "
292
0
                     "target!");
293
0
  }
294
295
296
  /// Order the symbols in the local stack frame.
297
  /// The list of objects that we want to order is in \p objectsToAllocate as
298
  /// indices into the MachineFrameInfo. The array can be reordered in any way
299
  /// upon return. The contents of the array, however, may not be modified (i.e.
300
  /// only their order may be changed).
301
  /// By default, just maintain the original order.
302
  virtual void
303
  orderFrameObjects(const MachineFunction &MF,
304
516k
                    SmallVectorImpl<int> &objectsToAllocate) const {
305
516k
  }
306
307
  /// Check whether or not the given \p MBB can be used as a prologue
308
  /// for the target.
309
  /// The prologue will be inserted first in this basic block.
310
  /// This method is used by the shrink-wrapping pass to decide if
311
  /// \p MBB will be correctly handled by the target.
312
  /// As soon as the target enable shrink-wrapping without overriding
313
  /// this method, we assume that each basic block is a valid
314
  /// prologue.
315
354
  virtual bool canUseAsPrologue(const MachineBasicBlock &MBB) const {
316
354
    return true;
317
354
  }
318
319
  /// Check whether or not the given \p MBB can be used as a epilogue
320
  /// for the target.
321
  /// The epilogue will be inserted before the first terminator of that block.
322
  /// This method is used by the shrink-wrapping pass to decide if
323
  /// \p MBB will be correctly handled by the target.
324
  /// As soon as the target enable shrink-wrapping without overriding
325
  /// this method, we assume that each basic block is a valid
326
  /// epilogue.
327
1.45k
  virtual bool canUseAsEpilogue(const MachineBasicBlock &MBB) const {
328
1.45k
    return true;
329
1.45k
  }
330
331
  /// Check if given function is safe for not having callee saved registers.
332
  /// This is used when interprocedural register allocation is enabled.
333
34
  static bool isSafeForNoCSROpt(const Function *F) {
334
34
    if (
!F->hasLocalLinkage() || 34
F->hasAddressTaken()2
||
335
2
        !F->hasFnAttribute(Attribute::NoRecurse))
336
32
      return false;
337
34
    // Function should not be optimized as tail call.
338
2
    for (const User *U : F->users())
339
2
      
if (auto 2
CS2
= ImmutableCallSite(U))
340
2
        
if (2
CS.isTailCall()2
)
341
0
          return false;
342
2
    return true;
343
34
  }
344
};
345
346
} // End llvm namespace
347
348
#endif