Coverage Report

Created: 2019-07-24 05:18

/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