LLVM  4.0.0
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"
26 #include "llvm/IR/InlineAsm.h"
27 #include "llvm/IR/Instructions.h"
29 #include <vector>
30 
31 namespace llvm {
32 
33 class AllocaInst;
34 class BasicBlock;
35 class BranchProbabilityInfo;
36 class Function;
37 class GlobalVariable;
38 class Instruction;
39 class MachineInstr;
40 class MachineBasicBlock;
41 class MachineFunction;
42 class MachineModuleInfo;
43 class MachineRegisterInfo;
44 class SelectionDAG;
45 class MVT;
46 class TargetLowering;
47 class Value;
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  /// The swifterror argument of the current function.
87 
89  /// A function can only have a single swifterror argument. And if it does
90  /// have a swifterror argument, it must be the first entry in
91  /// SwiftErrorVals.
93 
94 
95  /// Get or create the swifterror value virtual register in
96  /// SwiftErrorVRegDefMap for this basic block.
98  const Value *);
99 
100  /// Set the swifterror virtual register in the SwiftErrorVRegDefMap for this
101  /// basic block.
103  unsigned);
104 
105  /// ValueMap - Since we emit code for the function a basic block at a time,
106  /// we must remember which virtual registers hold the values for
107  /// cross-basic-block values.
109 
110  /// Track virtual registers created for exception pointers.
112 
113  /// Keep track of frame indices allocated for statepoints as they could be
114  /// used across basic block boundaries. This struct is more complex than a
115  /// simple map because the stateopint lowering code de-duplicates gc pointers
116  /// based on their SDValue (so %p and (bitcast %p to T) will get the same
117  /// slot), and we track that here.
118 
121 
122  /// Maps uniqued llvm IR values to the slots they were spilled in. If a
123  /// value is mapped to None it means we visited the value but didn't spill
124  /// it (because it was a constant, for instance).
126 
127  /// Maps llvm IR values to the values they were de-duplicated to.
129 
131  auto DuplIt = DuplicateMap.find(V);
132  if (DuplIt != DuplicateMap.end())
133  V = DuplIt->second;
134  return SlotMap.find(V);
135  }
136 
137  SlotMapTy::const_iterator end() const { return SlotMap.end(); }
138  };
139 
140  /// Maps gc.statepoint instructions to their corresponding StatepointSpillMap
141  /// instances.
143 
144  /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in
145  /// the entry block. This allows the allocas to be efficiently referenced
146  /// anywhere in the function.
148 
149  /// ByValArgFrameIndexMap - Keep track of frame indices for byval arguments.
151 
152  /// ArgDbgValues - A list of DBG_VALUE instructions created during isel for
153  /// function arguments that are inserted after scheduling is completed.
155 
156  /// RegFixups - Registers which need to be replaced after isel is done.
158 
159  /// StatepointStackSlots - A list of temporary stack slots (frame indices)
160  /// used to spill values at a statepoint. We store them here to enable
161  /// reuse of the same stack slots across different statepoints in different
162  /// basic blocks.
164 
165  /// MBB - The current block.
167 
168  /// MBB - The current insert position inside the current block.
170 
171  struct LiveOutInfo {
172  unsigned NumSignBits : 31;
173  unsigned IsValid : 1;
176  KnownZero(1, 0) {}
177  };
178 
179  /// Record the preferred extend type (ISD::SIGN_EXTEND or ISD::ZERO_EXTEND)
180  /// for a value.
182 
183  /// VisitedBBs - The set of basic blocks visited thus far by instruction
184  /// selection.
186 
187  /// PHINodesToUpdate - A list of phi instructions whose operand list will
188  /// be updated after processing the current basic block.
189  /// TODO: This isn't per-function state, it's per-basic-block state. But
190  /// there's no other convenient place for it to live right now.
191  std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate;
193 
194  /// If the current MBB is a landing pad, the exception pointer and exception
195  /// selector registers are copied into these virtual registers by
196  /// SelectionDAGISel::PrepareEHLandingPad().
198 
199  /// set - Initialize this FunctionLoweringInfo with the given Function
200  /// and its associated MachineFunction.
201  ///
202  void set(const Function &Fn, MachineFunction &MF, SelectionDAG *DAG);
203 
204  /// clear - Clear out all the function-specific state. This returns this
205  /// FunctionLoweringInfo to an empty state, ready to be used for a
206  /// different function.
207  void clear();
208 
209  /// isExportedInst - Return true if the specified value is an instruction
210  /// exported from its block.
211  bool isExportedInst(const Value *V) {
212  return ValueMap.count(V);
213  }
214 
215  unsigned CreateReg(MVT VT);
216 
217  unsigned CreateRegs(Type *Ty);
218 
219  unsigned InitializeRegForValue(const Value *V) {
220  // Tokens never live in vregs.
221  if (V->getType()->isTokenTy())
222  return 0;
223  unsigned &R = ValueMap[V];
224  assert(R == 0 && "Already initialized this value register!");
225  return R = CreateRegs(V->getType());
226  }
227 
228  /// GetLiveOutRegInfo - Gets LiveOutInfo for a register, returning NULL if the
229  /// register is a PHI destination and the PHI's LiveOutInfo is not valid.
230  const LiveOutInfo *GetLiveOutRegInfo(unsigned Reg) {
231  if (!LiveOutRegInfo.inBounds(Reg))
232  return nullptr;
233 
234  const LiveOutInfo *LOI = &LiveOutRegInfo[Reg];
235  if (!LOI->IsValid)
236  return nullptr;
237 
238  return LOI;
239  }
240 
241  /// GetLiveOutRegInfo - Gets LiveOutInfo for a register, returning NULL if the
242  /// register is a PHI destination and the PHI's LiveOutInfo is not valid. If
243  /// the register's LiveOutInfo is for a smaller bit width, it is extended to
244  /// the larger bit width by zero extension. The bit width must be no smaller
245  /// than the LiveOutInfo's existing bit width.
246  const LiveOutInfo *GetLiveOutRegInfo(unsigned Reg, unsigned BitWidth);
247 
248  /// AddLiveOutRegInfo - Adds LiveOutInfo for a register.
249  void AddLiveOutRegInfo(unsigned Reg, unsigned NumSignBits,
250  const APInt &KnownZero, const APInt &KnownOne) {
251  // Only install this information if it tells us something.
252  if (NumSignBits == 1 && KnownZero == 0 && KnownOne == 0)
253  return;
254 
255  LiveOutRegInfo.grow(Reg);
256  LiveOutInfo &LOI = LiveOutRegInfo[Reg];
257  LOI.NumSignBits = NumSignBits;
258  LOI.KnownOne = KnownOne;
259  LOI.KnownZero = KnownZero;
260  }
261 
262  /// ComputePHILiveOutRegInfo - Compute LiveOutInfo for a PHI's destination
263  /// register based on the LiveOutInfo of its operands.
264  void ComputePHILiveOutRegInfo(const PHINode*);
265 
266  /// InvalidatePHILiveOutRegInfo - Invalidates a PHI's LiveOutInfo, to be
267  /// called when a block is visited before all of its predecessors.
269  // PHIs with no uses have no ValueMap entry.
271  if (It == ValueMap.end())
272  return;
273 
274  unsigned Reg = It->second;
275  if (Reg == 0)
276  return;
277 
278  LiveOutRegInfo.grow(Reg);
279  LiveOutRegInfo[Reg].IsValid = false;
280  }
281 
282  /// setArgumentFrameIndex - Record frame index for the byval
283  /// argument.
284  void setArgumentFrameIndex(const Argument *A, int FI);
285 
286  /// getArgumentFrameIndex - Get frame index for the byval argument.
287  int getArgumentFrameIndex(const Argument *A);
288 
289  unsigned getCatchPadExceptionPointerVReg(const Value *CPI,
290  const TargetRegisterClass *RC);
291 
292 private:
293  void addSEHHandlersForLPads(ArrayRef<const LandingPadInst *> LPads);
294 
295  /// LiveOutRegInfo - Information about live out vregs.
297 };
298 
299 } // end namespace llvm
300 
301 #endif
llvm::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...
LLVM Argument representation.
Definition: Argument.h:34
Various leaf nodes.
Definition: ISDOpcodes.h:60
unsigned getCatchPadExceptionPointerVReg(const Value *CPI, const TargetRegisterClass *RC)
SlotMapTy::const_iterator find(const Value *V) const
size_type count(const KeyT &Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: ValueMap.h:154
bool isTokenTy() const
Return true if this is 'token'.
Definition: Type.h:192
DenseMap< const Value *, unsigned > CatchPadExceptionPointers
Track virtual registers created for exception pointers.
bool CanLowerReturn
CanLowerReturn - true iff the function'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...
void set(const Function &Fn, MachineFunction &MF, SelectionDAG *DAG)
set - Initialize this FunctionLoweringInfo with the given Function and its associated MachineFunction...
unsigned DemoteRegister
DemoteRegister - if CanLowerReturn is false, DemoteRegister is a vreg allocated to hold a pointer to ...
void AddLiveOutRegInfo(unsigned Reg, unsigned NumSignBits, const APInt &KnownZero, const APInt &KnownOne)
AddLiveOutRegInfo - Adds LiveOutInfo for a register.
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.
const LiveOutInfo * GetLiveOutRegInfo(unsigned Reg)
GetLiveOutRegInfo - Gets LiveOutInfo for a register, returning NULL if the register is a PHI destinat...
iterator find(const KeyT &Val)
Definition: ValueMap.h:158
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.
llvm::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...
std::vector< std::pair< MachineInstr *, unsigned > > PHINodesToUpdate
PHINodesToUpdate - A list of phi instructions whose operand list will be updated after processing the...
MVT - Machine Value Type.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
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'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...
iterator end()
Definition: ValueMap.h:138
bool SplitCSR
True if part of the CSRs will be handled via explicit copies.
See the file comment.
Definition: ValueMap.h:87
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:425
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:166
SmallVector< MachineInstr *, 8 > ArgDbgValues
ArgDbgValues - A list of DBG_VALUE instructions created during isel for function arguments that are i...
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:230
DenseMap< const Value *, const Value * > DuplicateMap
Maps llvm IR values to the values they were de-duplicated to.
unsigned CreateRegs(Type *Ty)
CreateRegs - Allocate the appropriate number of virtual registers of the correctly promoted or expand...
Class for arbitrary precision integers.
Definition: APInt.h:77
BranchProbabilityInfo * BPI
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.
FunctionLoweringInfo - This contains information that is global to a function that is used when lower...
iterator end()
Definition: DenseMap.h:69
iterator find(const KeyT &Val)
Definition: DenseMap.h:127
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...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void InvalidatePHILiveOutRegInfo(const PHINode *PN)
InvalidatePHILiveOutRegInfo - Invalidates a PHI's LiveOutInfo, to be called when a block is visited b...
SmallVector< const Value *, 1 > SwiftErrorValues
LLVM Value Representation.
Definition: Value.h:71
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.
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
DenseMap< const Value *, Optional< int > > SlotMapTy
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...