LLVM  6.0.0svn
FunctionLoweringInfo.h
Go to the documentation of this file.
1 //===- FunctionLoweringInfo.h - Lower functions from LLVM IR to CodeGen ---===//
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 implements routines for translating functions from LLVM IR into
11 // Machine IR.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CODEGEN_FUNCTIONLOWERINGINFO_H
16 #define LLVM_CODEGEN_FUNCTIONLOWERINGINFO_H
17 
18 #include "llvm/ADT/APInt.h"
19 #include "llvm/ADT/DenseMap.h"
20 #include "llvm/ADT/IndexedMap.h"
21 #include "llvm/ADT/Optional.h"
22 #include "llvm/ADT/SmallPtrSet.h"
23 #include "llvm/ADT/SmallVector.h"
27 #include "llvm/IR/Instructions.h"
28 #include "llvm/IR/Type.h"
29 #include "llvm/IR/Value.h"
30 #include "llvm/Support/KnownBits.h"
31 #include <cassert>
32 #include <utility>
33 #include <vector>
34 
35 namespace llvm {
36 
37 class Argument;
38 class BasicBlock;
39 class BranchProbabilityInfo;
40 class Function;
41 class Instruction;
42 class MachineFunction;
43 class MachineInstr;
44 class MachineRegisterInfo;
45 class MVT;
46 class SelectionDAG;
47 class TargetLowering;
48 
49 //===--------------------------------------------------------------------===//
50 /// FunctionLoweringInfo - This contains information that is global to a
51 /// function that is used when lowering a region of the function.
52 ///
54 public:
55  const Function *Fn;
60  /// CanLowerReturn - true iff the function's return value can be lowered to
61  /// registers.
63 
64  /// True if part of the CSRs will be handled via explicit copies.
65  bool SplitCSR;
66 
67  /// DemoteRegister - if CanLowerReturn is false, DemoteRegister is a vreg
68  /// allocated to hold a pointer to the hidden sret parameter.
69  unsigned DemoteRegister;
70 
71  /// MBBMap - A mapping from LLVM basic blocks to their machine code entry.
73 
74  /// A map from swifterror value in a basic block to the virtual register it is
75  /// currently represented by.
78 
79  /// A list of upward exposed vreg uses that need to be satisfied by either a
80  /// copy def or a phi node at the beginning of the basic block representing
81  /// the predecessor(s) swifterror value.
84 
85  /// A map from instructions that define/use a swifterror value to the virtual
86  /// register that represents that def/use.
89 
90  /// The swifterror argument of the current function.
92 
94  /// A function can only have a single swifterror argument. And if it does
95  /// have a swifterror argument, it must be the first entry in
96  /// SwiftErrorVals.
98 
99  /// Get or create the swifterror value virtual register in
100  /// SwiftErrorVRegDefMap for this basic block.
102  const Value *);
103 
104  /// Set the swifterror virtual register in the SwiftErrorVRegDefMap for this
105  /// basic block.
107  unsigned);
108 
109  /// Get or create the swifterror value virtual register for a def of a
110  /// swifterror by an instruction.
111  std::pair<unsigned, bool> getOrCreateSwiftErrorVRegDefAt(const Instruction *);
112  std::pair<unsigned, bool>
114  const Value *);
115 
116  /// ValueMap - Since we emit code for the function a basic block at a time,
117  /// we must remember which virtual registers hold the values for
118  /// cross-basic-block values.
120 
121  /// Track virtual registers created for exception pointers.
123 
124  /// Keep track of frame indices allocated for statepoints as they could be
125  /// used across basic block boundaries. This struct is more complex than a
126  /// simple map because the stateopint lowering code de-duplicates gc pointers
127  /// based on their SDValue (so %p and (bitcast %p to T) will get the same
128  /// slot), and we track that here.
129 
132 
133  /// Maps uniqued llvm IR values to the slots they were spilled in. If a
134  /// value is mapped to None it means we visited the value but didn't spill
135  /// it (because it was a constant, for instance).
137 
138  /// Maps llvm IR values to the values they were de-duplicated to.
140 
142  auto DuplIt = DuplicateMap.find(V);
143  if (DuplIt != DuplicateMap.end())
144  V = DuplIt->second;
145  return SlotMap.find(V);
146  }
147 
148  SlotMapTy::const_iterator end() const { return SlotMap.end(); }
149  };
150 
151  /// Maps gc.statepoint instructions to their corresponding StatepointSpillMap
152  /// instances.
154 
155  /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in
156  /// the entry block. This allows the allocas to be efficiently referenced
157  /// anywhere in the function.
159 
160  /// ByValArgFrameIndexMap - Keep track of frame indices for byval arguments.
162 
163  /// ArgDbgValues - A list of DBG_VALUE instructions created during isel for
164  /// function arguments that are inserted after scheduling is completed.
166 
167  /// RegFixups - Registers which need to be replaced after isel is done.
169 
170  /// StatepointStackSlots - A list of temporary stack slots (frame indices)
171  /// used to spill values at a statepoint. We store them here to enable
172  /// reuse of the same stack slots across different statepoints in different
173  /// basic blocks.
175 
176  /// MBB - The current block.
178 
179  /// MBB - The current insert position inside the current block.
181 
182  struct LiveOutInfo {
183  unsigned NumSignBits : 31;
184  unsigned IsValid : 1;
185  KnownBits Known = 1;
186 
187  LiveOutInfo() : NumSignBits(0), IsValid(true) {}
188  };
189 
190  /// Record the preferred extend type (ISD::SIGN_EXTEND or ISD::ZERO_EXTEND)
191  /// for a value.
193 
194  /// VisitedBBs - The set of basic blocks visited thus far by instruction
195  /// selection.
197 
198  /// PHINodesToUpdate - A list of phi instructions whose operand list will
199  /// be updated after processing the current basic block.
200  /// TODO: This isn't per-function state, it's per-basic-block state. But
201  /// there's no other convenient place for it to live right now.
202  std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate;
204 
205  /// If the current MBB is a landing pad, the exception pointer and exception
206  /// selector registers are copied into these virtual registers by
207  /// SelectionDAGISel::PrepareEHLandingPad().
209 
210  /// set - Initialize this FunctionLoweringInfo with the given Function
211  /// and its associated MachineFunction.
212  ///
213  void set(const Function &Fn, MachineFunction &MF, SelectionDAG *DAG);
214 
215  /// clear - Clear out all the function-specific state. This returns this
216  /// FunctionLoweringInfo to an empty state, ready to be used for a
217  /// different function.
218  void clear();
219 
220  /// isExportedInst - Return true if the specified value is an instruction
221  /// exported from its block.
222  bool isExportedInst(const Value *V) {
223  return ValueMap.count(V);
224  }
225 
226  unsigned CreateReg(MVT VT);
227 
228  unsigned CreateRegs(Type *Ty);
229 
230  unsigned InitializeRegForValue(const Value *V) {
231  // Tokens never live in vregs.
232  if (V->getType()->isTokenTy())
233  return 0;
234  unsigned &R = ValueMap[V];
235  assert(R == 0 && "Already initialized this value register!");
236  return R = CreateRegs(V->getType());
237  }
238 
239  /// GetLiveOutRegInfo - Gets LiveOutInfo for a register, returning NULL if the
240  /// register is a PHI destination and the PHI's LiveOutInfo is not valid.
241  const LiveOutInfo *GetLiveOutRegInfo(unsigned Reg) {
242  if (!LiveOutRegInfo.inBounds(Reg))
243  return nullptr;
244 
245  const LiveOutInfo *LOI = &LiveOutRegInfo[Reg];
246  if (!LOI->IsValid)
247  return nullptr;
248 
249  return LOI;
250  }
251 
252  /// GetLiveOutRegInfo - Gets LiveOutInfo for a register, returning NULL if the
253  /// register is a PHI destination and the PHI's LiveOutInfo is not valid. If
254  /// the register's LiveOutInfo is for a smaller bit width, it is extended to
255  /// the larger bit width by zero extension. The bit width must be no smaller
256  /// than the LiveOutInfo's existing bit width.
257  const LiveOutInfo *GetLiveOutRegInfo(unsigned Reg, unsigned BitWidth);
258 
259  /// AddLiveOutRegInfo - Adds LiveOutInfo for a register.
260  void AddLiveOutRegInfo(unsigned Reg, unsigned NumSignBits,
261  const KnownBits &Known) {
262  // Only install this information if it tells us something.
263  if (NumSignBits == 1 && Known.isUnknown())
264  return;
265 
266  LiveOutRegInfo.grow(Reg);
267  LiveOutInfo &LOI = LiveOutRegInfo[Reg];
268  LOI.NumSignBits = NumSignBits;
269  LOI.Known.One = Known.One;
270  LOI.Known.Zero = Known.Zero;
271  }
272 
273  /// ComputePHILiveOutRegInfo - Compute LiveOutInfo for a PHI's destination
274  /// register based on the LiveOutInfo of its operands.
275  void ComputePHILiveOutRegInfo(const PHINode*);
276 
277  /// InvalidatePHILiveOutRegInfo - Invalidates a PHI's LiveOutInfo, to be
278  /// called when a block is visited before all of its predecessors.
280  // PHIs with no uses have no ValueMap entry.
282  if (It == ValueMap.end())
283  return;
284 
285  unsigned Reg = It->second;
286  if (Reg == 0)
287  return;
288 
289  LiveOutRegInfo.grow(Reg);
290  LiveOutRegInfo[Reg].IsValid = false;
291  }
292 
293  /// setArgumentFrameIndex - Record frame index for the byval
294  /// argument.
295  void setArgumentFrameIndex(const Argument *A, int FI);
296 
297  /// getArgumentFrameIndex - Get frame index for the byval argument.
298  int getArgumentFrameIndex(const Argument *A);
299 
300  unsigned getCatchPadExceptionPointerVReg(const Value *CPI,
301  const TargetRegisterClass *RC);
302 
303 private:
304  void addSEHHandlersForLPads(ArrayRef<const LandingPadInst *> LPads);
305 
306  /// LiveOutRegInfo - Information about live out vregs.
308 };
309 
310 } // end namespace llvm
311 
312 #endif // LLVM_CODEGEN_FUNCTIONLOWERINGINFO_H
This class represents an incoming formal argument to a Function.
Definition: Argument.h:30
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
Various leaf nodes.
Definition: ISDOpcodes.h:60
unsigned getCatchPadExceptionPointerVReg(const Value *CPI, const TargetRegisterClass *RC)
DenseMap< const Value *, unsigned > CatchPadExceptionPointers
Track virtual registers created for exception pointers.
bool CanLowerReturn
CanLowerReturn - true iff the function&#39;s return value can be lowered to registers.
void setCurrentSwiftErrorVReg(const MachineBasicBlock *MBB, const Value *, unsigned)
Set the swifterror virtual register in the SwiftErrorVRegDefMap for this basic block.
Keep track of frame indices allocated for statepoints as they could be used across basic block bounda...
std::pair< unsigned, bool > getOrCreateSwiftErrorVRegDefAt(const Instruction *)
Get or create the swifterror value virtual register for a def of a swifterror by an instruction...
unsigned DemoteRegister
DemoteRegister - if CanLowerReturn is false, DemoteRegister is a vreg allocated to hold a pointer to ...
const Value * SwiftErrorArg
The swifterror argument of the current function.
DenseMap< const Value *, unsigned > ValueMap
ValueMap - Since we emit code for the function a basic block at a time, we must remember which virtua...
Reg
All possible values of the reg field in the ModR/M byte.
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
This file implements a class to represent arbitrary precision integral constant values and operations...
int getArgumentFrameIndex(const Argument *A)
getArgumentFrameIndex - Get frame index for the byval argument.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
const LiveOutInfo * GetLiveOutRegInfo(unsigned Reg)
GetLiveOutRegInfo - Gets LiveOutInfo for a register, returning NULL if the register is a PHI destinat...
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
void clear()
clear - Clear out all the function-specific state.
SlotMapTy SlotMap
Maps uniqued llvm IR values to the slots they were spilled in.
std::vector< std::pair< MachineInstr *, unsigned > > PHINodesToUpdate
PHINodesToUpdate - A list of phi instructions whose operand list will be updated after processing the...
Machine Value Type.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
std::pair< unsigned, bool > getOrCreateSwiftErrorVRegUseAt(const Instruction *, const MachineBasicBlock *, const Value *)
void grow(unsigned AtLeast)
Definition: DenseMap.h:728
void AddLiveOutRegInfo(unsigned Reg, unsigned NumSignBits, const KnownBits &Known)
AddLiveOutRegInfo - Adds LiveOutInfo for a register.
DenseMap< const Instruction *, StatepointSpillMap > StatepointSpillMaps
Maps gc.statepoint instructions to their corresponding StatepointSpillMap instances.
unsigned ExceptionPointerVirtReg
If the current MBB is a landing pad, the exception pointer and exception selector registers are copie...
SmallPtrSet< const BasicBlock *, 4 > VisitedBBs
VisitedBBs - The set of basic blocks visited thus far by instruction selection.
void ComputePHILiveOutRegInfo(const PHINode *)
ComputePHILiveOutRegInfo - Compute LiveOutInfo for a PHI&#39;s destination register based on the LiveOutI...
MachineBasicBlock * MBB
MBB - The current block.
SmallVector< unsigned, 50 > StatepointStackSlots
StatepointStackSlots - A list of temporary stack slots (frame indices) used to spill values at a stat...
bool SplitCSR
True if part of the CSRs will be handled via explicit copies.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:418
DenseMap< std::pair< const MachineBasicBlock *, const Value * >, unsigned > SwiftErrorVRegDefMap
A map from swifterror value in a basic block to the virtual register it is currently represented by...
DenseMap< unsigned, unsigned > RegFixups
RegFixups - Registers which need to be replaced after isel is done.
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:209
SmallVector< MachineInstr *, 8 > ArgDbgValues
ArgDbgValues - A list of DBG_VALUE instructions created during isel for function arguments that are i...
DenseMap< const Value *, const Value * > DuplicateMap
Maps llvm IR values to the values they were de-duplicated to.
DenseMap< std::pair< const MachineBasicBlock *, const Value * >, unsigned > SwiftErrorVRegUpwardsUse
A list of upward exposed vreg uses that need to be satisfied by either a copy def or a phi node at th...
unsigned CreateRegs(Type *Ty)
CreateRegs - Allocate the appropriate number of virtual registers of the correctly promoted or expand...
BranchProbabilityInfo * BPI
bool isUnknown() const
Returns true if we don&#39;t know any bits.
Definition: KnownBits.h:63
MachineRegisterInfo - Keep track of information for virtual and physical registers, including vreg register classes, use/def chains for registers, etc.
DenseMap< const Value *, ISD::NodeType > PreferredExtendType
Record the preferred extend type (ISD::SIGN_EXTEND or ISD::ZERO_EXTEND) for a value.
Basic Alias true
Analysis providing branch probability information.
MachineRegisterInfo * RegInfo
DenseMap< const Argument *, int > ByValArgFrameIndexMap
ByValArgFrameIndexMap - Keep track of frame indices for byval arguments.
bool isTokenTy() const
Return true if this is &#39;token&#39;.
Definition: Type.h:194
FunctionLoweringInfo - This contains information that is global to a function that is used when lower...
MachineBasicBlock::iterator InsertPt
MBB - The current insert position inside the current block.
unsigned CreateReg(MVT VT)
CreateReg - Allocate a single virtual register for the given type.
DenseMap< const AllocaInst *, int > StaticAllocaMap
StaticAllocaMap - Keep track of frame indices for fixed sized allocas in the entry block...
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:141
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void InvalidatePHILiveOutRegInfo(const PHINode *PN)
InvalidatePHILiveOutRegInfo - Invalidates a PHI&#39;s LiveOutInfo, to be called when a block is visited b...
LLVM Value Representation.
Definition: Value.h:73
llvm::DenseMap< PointerIntPair< const Instruction *, 1, bool >, unsigned > SwiftErrorVRegDefUses
A map from instructions that define/use a swifterror value to the virtual register that represents th...
SlotMapTy::const_iterator find(const Value *V) const
DenseMap< const BasicBlock *, MachineBasicBlock * > MBBMap
MBBMap - A mapping from LLVM basic blocks to their machine code entry.
SwiftErrorValues SwiftErrorVals
A function can only have a single swifterror argument.
const TargetLowering * TLI
void setArgumentFrameIndex(const Argument *A, int FI)
setArgumentFrameIndex - Record frame index for the byval argument.
bool isExportedInst(const Value *V)
isExportedInst - Return true if the specified value is an instruction exported from its block...
unsigned InitializeRegForValue(const Value *V)
unsigned getOrCreateSwiftErrorVReg(const MachineBasicBlock *, const Value *)
Get or create the swifterror value virtual register in SwiftErrorVRegDefMap for this basic block...