LLVM  14.0.0git
FunctionLoweringInfo.h
Go to the documentation of this file.
1 //===- FunctionLoweringInfo.h - Lower functions from LLVM IR ---*- 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 // This implements routines for translating functions from LLVM IR into
10 // Machine IR.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CODEGEN_FUNCTIONLOWERINGINFO_H
15 #define LLVM_CODEGEN_FUNCTIONLOWERINGINFO_H
16 
17 #include "llvm/ADT/BitVector.h"
18 #include "llvm/ADT/DenseMap.h"
19 #include "llvm/ADT/IndexedMap.h"
20 #include "llvm/ADT/Optional.h"
21 #include "llvm/ADT/SmallPtrSet.h"
22 #include "llvm/ADT/SmallVector.h"
26 #include "llvm/IR/Instructions.h"
27 #include "llvm/IR/Type.h"
28 #include "llvm/IR/Value.h"
29 #include "llvm/Support/KnownBits.h"
30 #include <cassert>
31 #include <utility>
32 #include <vector>
33 
34 namespace llvm {
35 
36 class Argument;
37 class BasicBlock;
38 class BranchProbabilityInfo;
39 class LegacyDivergenceAnalysis;
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;
61  /// CanLowerReturn - true iff the function's return value can be lowered to
62  /// registers.
64 
65  /// True if part of the CSRs will be handled via explicit copies.
66  bool SplitCSR;
67 
68  /// DemoteRegister - if CanLowerReturn is false, DemoteRegister is a vreg
69  /// allocated to hold a pointer to the hidden sret parameter.
71 
72  /// MBBMap - A mapping from LLVM basic blocks to their machine code entry.
74 
75  /// ValueMap - Since we emit code for the function a basic block at a time,
76  /// we must remember which virtual registers hold the values for
77  /// cross-basic-block values.
79 
80  /// VirtReg2Value map is needed by the Divergence Analysis driven
81  /// instruction selection. It is reverted ValueMap. It is computed
82  /// in lazy style - on demand. It is used to get the Value corresponding
83  /// to the live in virtual register and is called from the
84  /// TargetLowerinInfo::isSDNodeSourceOfDivergence.
86 
87  /// This method is called from TargetLowerinInfo::isSDNodeSourceOfDivergence
88  /// to get the Value corresponding to the live-in virtual register.
90 
91  /// Track virtual registers created for exception pointers.
93 
94  /// Helper object to track which of three possible relocation mechanisms are
95  /// used for a particular value being relocated over a statepoint.
97  enum RelocType {
98  // Value did not need to be relocated and can be used directly.
100  // Value was spilled to stack and needs filled at the gc.relocate.
102  // Value was lowered to tied def and gc.relocate should be replaced with
103  // copy from vreg.
105  } type = NoRelocate;
106  // Payload contains either frame index of the stack slot in which the value
107  // was spilled, or virtual register which contains the re-definition.
108  union payload_t {
109  payload_t() : FI(-1) {}
110  int FI;
112  } payload;
113  };
114 
115  /// Keep track of each value which was relocated and the strategy used to
116  /// relocate that value. This information is required when visiting
117  /// gc.relocates which may appear in following blocks.
118  using StatepointSpillMapTy =
121 
122  /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in
123  /// the entry block. This allows the allocas to be efficiently referenced
124  /// anywhere in the function.
126 
127  /// ByValArgFrameIndexMap - Keep track of frame indices for byval arguments.
129 
130  /// ArgDbgValues - A list of DBG_VALUE instructions created during isel for
131  /// function arguments that are inserted after scheduling is completed.
133 
134  /// Bitvector with a bit set if corresponding argument is described in
135  /// ArgDbgValues. Using arg numbers according to Argument numbering.
137 
138  /// RegFixups - Registers which need to be replaced after isel is done.
140 
142 
143  /// StatepointStackSlots - A list of temporary stack slots (frame indices)
144  /// used to spill values at a statepoint. We store them here to enable
145  /// reuse of the same stack slots across different statepoints in different
146  /// basic blocks.
148 
149  /// MBB - The current block.
151 
152  /// MBB - The current insert position inside the current block.
154 
155  struct LiveOutInfo {
156  unsigned NumSignBits : 31;
157  unsigned IsValid : 1;
159 
161  };
162 
163  /// Record the preferred extend type (ISD::SIGN_EXTEND or ISD::ZERO_EXTEND)
164  /// for a value.
166 
167  /// VisitedBBs - The set of basic blocks visited thus far by instruction
168  /// selection.
170 
171  /// PHINodesToUpdate - A list of phi instructions whose operand list will
172  /// be updated after processing the current basic block.
173  /// TODO: This isn't per-function state, it's per-basic-block state. But
174  /// there's no other convenient place for it to live right now.
175  std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate;
177 
178  /// If the current MBB is a landing pad, the exception pointer and exception
179  /// selector registers are copied into these virtual registers by
180  /// SelectionDAGISel::PrepareEHLandingPad().
182 
183  /// set - Initialize this FunctionLoweringInfo with the given Function
184  /// and its associated MachineFunction.
185  ///
186  void set(const Function &Fn, MachineFunction &MF, SelectionDAG *DAG);
187 
188  /// clear - Clear out all the function-specific state. This returns this
189  /// FunctionLoweringInfo to an empty state, ready to be used for a
190  /// different function.
191  void clear();
192 
193  /// isExportedInst - Return true if the specified value is an instruction
194  /// exported from its block.
195  bool isExportedInst(const Value *V) const {
196  return ValueMap.count(V);
197  }
198 
199  Register CreateReg(MVT VT, bool isDivergent = false);
200 
201  Register CreateRegs(const Value *V);
202 
203  Register CreateRegs(Type *Ty, bool isDivergent = false);
204 
206  // Tokens never live in vregs.
207  if (V->getType()->isTokenTy())
208  return 0;
209  Register &R = ValueMap[V];
210  assert(R == 0 && "Already initialized this value register!");
211  assert(VirtReg2Value.empty());
212  return R = CreateRegs(V);
213  }
214 
215  /// GetLiveOutRegInfo - Gets LiveOutInfo for a register, returning NULL if the
216  /// register is a PHI destination and the PHI's LiveOutInfo is not valid.
218  if (!LiveOutRegInfo.inBounds(Reg))
219  return nullptr;
220 
221  const LiveOutInfo *LOI = &LiveOutRegInfo[Reg];
222  if (!LOI->IsValid)
223  return nullptr;
224 
225  return LOI;
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. If
230  /// the register's LiveOutInfo is for a smaller bit width, it is extended to
231  /// the larger bit width by zero extension. The bit width must be no smaller
232  /// than the LiveOutInfo's existing bit width.
233  const LiveOutInfo *GetLiveOutRegInfo(Register Reg, unsigned BitWidth);
234 
235  /// AddLiveOutRegInfo - Adds LiveOutInfo for a register.
236  void AddLiveOutRegInfo(Register Reg, unsigned NumSignBits,
237  const KnownBits &Known) {
238  // Only install this information if it tells us something.
239  if (NumSignBits == 1 && Known.isUnknown())
240  return;
241 
242  LiveOutRegInfo.grow(Reg);
243  LiveOutInfo &LOI = LiveOutRegInfo[Reg];
244  LOI.NumSignBits = NumSignBits;
245  LOI.Known.One = Known.One;
246  LOI.Known.Zero = Known.Zero;
247  }
248 
249  /// ComputePHILiveOutRegInfo - Compute LiveOutInfo for a PHI's destination
250  /// register based on the LiveOutInfo of its operands.
251  void ComputePHILiveOutRegInfo(const PHINode*);
252 
253  /// InvalidatePHILiveOutRegInfo - Invalidates a PHI's LiveOutInfo, to be
254  /// called when a block is visited before all of its predecessors.
256  // PHIs with no uses have no ValueMap entry.
258  if (It == ValueMap.end())
259  return;
260 
261  Register Reg = It->second;
262  if (Reg == 0)
263  return;
264 
265  LiveOutRegInfo.grow(Reg);
266  LiveOutRegInfo[Reg].IsValid = false;
267  }
268 
269  /// setArgumentFrameIndex - Record frame index for the byval
270  /// argument.
271  void setArgumentFrameIndex(const Argument *A, int FI);
272 
273  /// getArgumentFrameIndex - Get frame index for the byval argument.
274  int getArgumentFrameIndex(const Argument *A);
275 
277  const TargetRegisterClass *RC);
278 
279 private:
280  /// LiveOutRegInfo - Information about live out vregs.
282 };
283 
284 } // end namespace llvm
285 
286 #endif // LLVM_CODEGEN_FUNCTIONLOWERINGINFO_H
llvm::FunctionLoweringInfo::Fn
const Function * Fn
Definition: FunctionLoweringInfo.h:55
llvm::Argument
This class represents an incoming formal argument to a Function.
Definition: Argument.h:29
llvm::FunctionLoweringInfo::StatepointRelocationRecord::payload
union llvm::FunctionLoweringInfo::StatepointRelocationRecord::payload_t payload
llvm::FunctionLoweringInfo::StaticAllocaMap
DenseMap< const AllocaInst *, int > StaticAllocaMap
StaticAllocaMap - Keep track of frame indices for fixed sized allocas in the entry block.
Definition: FunctionLoweringInfo.h:125
IndexedMap.h
llvm::FunctionLoweringInfo::StatepointRelocationRecord::payload_t::payload_t
payload_t()
Definition: FunctionLoweringInfo.h:109
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
Reg
unsigned Reg
Definition: MachineSink.cpp:1566
Optional.h
llvm::FunctionLoweringInfo::set
void set(const Function &Fn, MachineFunction &MF, SelectionDAG *DAG)
set - Initialize this FunctionLoweringInfo with the given Function and its associated MachineFunction...
Definition: FunctionLoweringInfo.cpp:82
llvm::FunctionLoweringInfo::AddLiveOutRegInfo
void AddLiveOutRegInfo(Register Reg, unsigned NumSignBits, const KnownBits &Known)
AddLiveOutRegInfo - Adds LiveOutInfo for a register.
Definition: FunctionLoweringInfo.h:236
llvm::FunctionLoweringInfo::ExceptionPointerVirtReg
unsigned ExceptionPointerVirtReg
If the current MBB is a landing pad, the exception pointer and exception selector registers are copie...
Definition: FunctionLoweringInfo.h:181
llvm::FunctionLoweringInfo::ExceptionSelectorVirtReg
unsigned ExceptionSelectorVirtReg
Definition: FunctionLoweringInfo.h:181
llvm::ValueMap::end
iterator end()
Definition: ValueMap.h:136
llvm::MachineRegisterInfo
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Definition: MachineRegisterInfo.h:52
llvm::Function
Definition: Function.h:61
llvm::FunctionLoweringInfo::LiveOutInfo
Definition: FunctionLoweringInfo.h:155
llvm::FunctionLoweringInfo::InsertPt
MachineBasicBlock::iterator InsertPt
MBB - The current insert position inside the current block.
Definition: FunctionLoweringInfo.h:153
llvm::KnownBits::Zero
APInt Zero
Definition: KnownBits.h:24
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
llvm::FunctionLoweringInfo::StatepointRelocationRecord
Helper object to track which of three possible relocation mechanisms are used for a particular value ...
Definition: FunctionLoweringInfo.h:96
llvm::KnownBits::isUnknown
bool isUnknown() const
Returns true if we don't know any bits.
Definition: KnownBits.h:63
llvm::FunctionLoweringInfo::RegsWithFixups
DenseSet< Register > RegsWithFixups
Definition: FunctionLoweringInfo.h:141
llvm::FunctionLoweringInfo::StatepointRelocationRecord::payload_t
Definition: FunctionLoweringInfo.h:108
MachineBasicBlock.h
llvm::DenseMapIterator
Definition: DenseMap.h:56
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
DenseMap.h
llvm::FunctionLoweringInfo::MBB
MachineBasicBlock * MBB
MBB - The current block.
Definition: FunctionLoweringInfo.h:150
llvm::FunctionLoweringInfo::isExportedInst
bool isExportedInst(const Value *V) const
isExportedInst - Return true if the specified value is an instruction exported from its block.
Definition: FunctionLoweringInfo.h:195
llvm::FunctionLoweringInfo::ValueMap
DenseMap< const Value *, Register > ValueMap
ValueMap - Since we emit code for the function a basic block at a time, we must remember which virtua...
Definition: FunctionLoweringInfo.h:78
llvm::SmallPtrSet< const BasicBlock *, 4 >
llvm::FunctionLoweringInfo::DescribedArgs
BitVector DescribedArgs
Bitvector with a bit set if corresponding argument is described in ArgDbgValues.
Definition: FunctionLoweringInfo.h:136
llvm::FunctionLoweringInfo::CanLowerReturn
bool CanLowerReturn
CanLowerReturn - true iff the function's return value can be lowered to registers.
Definition: FunctionLoweringInfo.h:63
llvm::FunctionLoweringInfo::StatepointRelocationRecord::VReg
@ VReg
Definition: FunctionLoweringInfo.h:104
llvm::FunctionLoweringInfo::getValueFromVirtualReg
const Value * getValueFromVirtualReg(Register Vreg)
This method is called from TargetLowerinInfo::isSDNodeSourceOfDivergence to get the Value correspondi...
Definition: FunctionLoweringInfo.cpp:552
KnownBits.h
llvm::FunctionLoweringInfo::StatepointStackSlots
SmallVector< unsigned, 50 > StatepointStackSlots
StatepointStackSlots - A list of temporary stack slots (frame indices) used to spill values at a stat...
Definition: FunctionLoweringInfo.h:147
llvm::FunctionLoweringInfo::DemoteRegister
Register DemoteRegister
DemoteRegister - if CanLowerReturn is false, DemoteRegister is a vreg allocated to hold a pointer to ...
Definition: FunctionLoweringInfo.h:70
llvm::SelectionDAG
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:216
llvm::FunctionLoweringInfo::MBBMap
DenseMap< const BasicBlock *, MachineBasicBlock * > MBBMap
MBBMap - A mapping from LLVM basic blocks to their machine code entry.
Definition: FunctionLoweringInfo.h:73
llvm::FunctionLoweringInfo::LiveOutInfo::LiveOutInfo
LiveOutInfo()
Definition: FunctionLoweringInfo.h:160
llvm::TargetLowering
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
Definition: TargetLowering.h:3170
llvm::KnownBits::One
APInt One
Definition: KnownBits.h:25
llvm::FunctionLoweringInfo::ArgDbgValues
SmallVector< MachineInstr *, 8 > ArgDbgValues
ArgDbgValues - A list of DBG_VALUE instructions created during isel for function arguments that are i...
Definition: FunctionLoweringInfo.h:132
llvm::BranchProbabilityInfo
Analysis providing branch probability information.
Definition: BranchProbabilityInfo.h:115
llvm::IndexedMap
Definition: IndexedMap.h:29
llvm::TargetRegisterClass
Definition: TargetRegisterInfo.h:46
llvm::FunctionLoweringInfo::ComputePHILiveOutRegInfo
void ComputePHILiveOutRegInfo(const PHINode *)
ComputePHILiveOutRegInfo - Compute LiveOutInfo for a PHI's destination register based on the LiveOutI...
Definition: FunctionLoweringInfo.cpp:435
llvm::FunctionLoweringInfo::GetLiveOutRegInfo
const LiveOutInfo * GetLiveOutRegInfo(Register Reg)
GetLiveOutRegInfo - Gets LiveOutInfo for a register, returning NULL if the register is a PHI destinat...
Definition: FunctionLoweringInfo.h:217
llvm::FunctionLoweringInfo::LiveOutInfo::NumSignBits
unsigned NumSignBits
Definition: FunctionLoweringInfo.h:156
llvm::Type::isTokenTy
bool isTokenTy() const
Return true if this is 'token'.
Definition: Type.h:198
BitVector.h
llvm::FunctionLoweringInfo::LiveOutInfo::Known
KnownBits Known
Definition: FunctionLoweringInfo.h:158
llvm::LegacyDivergenceAnalysis
Definition: LegacyDivergenceAnalysis.h:31
llvm::FunctionLoweringInfo::LiveOutInfo::IsValid
unsigned IsValid
Definition: FunctionLoweringInfo.h:157
llvm::FunctionLoweringInfo::BPI
BranchProbabilityInfo * BPI
Definition: FunctionLoweringInfo.h:59
SmallPtrSet.h
llvm::BitVector
Definition: BitVector.h:74
llvm::FunctionLoweringInfo::InitializeRegForValue
Register InitializeRegForValue(const Value *V)
Definition: FunctionLoweringInfo.h:205
llvm::ValueMap::count
size_type count(const KeyT &Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: ValueMap.h:152
llvm::FunctionLoweringInfo::OrigNumPHINodesToUpdate
unsigned OrigNumPHINodesToUpdate
Definition: FunctionLoweringInfo.h:176
Type.h
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
llvm::FunctionLoweringInfo::StatepointRelocationRecord::payload_t::Reg
Register Reg
Definition: FunctionLoweringInfo.h:111
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
llvm::FunctionLoweringInfo::TLI
const TargetLowering * TLI
Definition: FunctionLoweringInfo.h:57
llvm::DenseMap
Definition: DenseMap.h:714
llvm::FunctionLoweringInfo::SplitCSR
bool SplitCSR
True if part of the CSRs will be handled via explicit copies.
Definition: FunctionLoweringInfo.h:66
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::FunctionLoweringInfo
FunctionLoweringInfo - This contains information that is global to a function that is used when lower...
Definition: FunctionLoweringInfo.h:53
llvm::FunctionLoweringInfo::CatchPadExceptionPointers
DenseMap< const Value *, Register > CatchPadExceptionPointers
Track virtual registers created for exception pointers.
Definition: FunctionLoweringInfo.h:92
llvm::FunctionLoweringInfo::CreateRegs
Register CreateRegs(const Value *V)
Definition: FunctionLoweringInfo.cpp:406
llvm::ISD::BasicBlock
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
llvm::MVT
Machine Value Type.
Definition: MachineValueType.h:31
llvm::FunctionLoweringInfo::ByValArgFrameIndexMap
DenseMap< const Argument *, int > ByValArgFrameIndexMap
ByValArgFrameIndexMap - Keep track of frame indices for byval arguments.
Definition: FunctionLoweringInfo.h:128
llvm::MachineFunction
Definition: MachineFunction.h:230
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:256
llvm::FunctionLoweringInfo::StatepointRelocationMaps
DenseMap< const Instruction *, StatepointSpillMapTy > StatepointRelocationMaps
Definition: FunctionLoweringInfo.h:120
llvm::ValueMap
See the file comment.
Definition: ValueMap.h:85
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::FunctionLoweringInfo::VisitedBBs
SmallPtrSet< const BasicBlock *, 4 > VisitedBBs
VisitedBBs - The set of basic blocks visited thus far by instruction selection.
Definition: FunctionLoweringInfo.h:169
llvm::FunctionLoweringInfo::InvalidatePHILiveOutRegInfo
void InvalidatePHILiveOutRegInfo(const PHINode *PN)
InvalidatePHILiveOutRegInfo - Invalidates a PHI's LiveOutInfo, to be called when a block is visited b...
Definition: FunctionLoweringInfo.h:255
llvm::KnownBits
Definition: KnownBits.h:23
llvm::FunctionLoweringInfo::StatepointRelocationRecord::Spill
@ Spill
Definition: FunctionLoweringInfo.h:101
llvm::FunctionLoweringInfo::StatepointRelocationRecord::payload_t::FI
int FI
Definition: FunctionLoweringInfo.h:110
ISDOpcodes.h
llvm::FunctionLoweringInfo::clear
void clear()
clear - Clear out all the function-specific state.
Definition: FunctionLoweringInfo.cpp:356
llvm::BitWidth
constexpr unsigned BitWidth
Definition: BitmaskEnum.h:147
llvm::ValueMap::find
iterator find(const KeyT &Val)
Definition: ValueMap.h:156
llvm::FunctionLoweringInfo::setArgumentFrameIndex
void setArgumentFrameIndex(const Argument *A, int FI)
setArgumentFrameIndex - Record frame index for the byval argument.
Definition: FunctionLoweringInfo.cpp:524
llvm::FunctionLoweringInfo::RegFixups
DenseMap< Register, Register > RegFixups
RegFixups - Registers which need to be replaced after isel is done.
Definition: FunctionLoweringInfo.h:139
llvm::FunctionLoweringInfo::StatepointRelocationRecord::NoRelocate
@ NoRelocate
Definition: FunctionLoweringInfo.h:99
Instructions.h
llvm::FunctionLoweringInfo::MF
MachineFunction * MF
Definition: FunctionLoweringInfo.h:56
SmallVector.h
llvm::FunctionLoweringInfo::VirtReg2Value
DenseMap< Register, const Value * > VirtReg2Value
VirtReg2Value map is needed by the Divergence Analysis driven instruction selection.
Definition: FunctionLoweringInfo.h:85
llvm::PHINode
Definition: Instructions.h:2597
llvm::FunctionLoweringInfo::StatepointRelocationRecord::RelocType
RelocType
Definition: FunctionLoweringInfo.h:97
llvm::FunctionLoweringInfo::PHINodesToUpdate
std::vector< std::pair< MachineInstr *, unsigned > > PHINodesToUpdate
PHINodesToUpdate - A list of phi instructions whose operand list will be updated after processing the...
Definition: FunctionLoweringInfo.h:175
llvm::FunctionLoweringInfo::getArgumentFrameIndex
int getArgumentFrameIndex(const Argument *A)
getArgumentFrameIndex - Get frame index for the byval argument.
Definition: FunctionLoweringInfo.cpp:532
true
basic Basic Alias true
Definition: BasicAliasAnalysis.cpp:1815
llvm::MachineInstrBundleIterator< MachineInstr >
Value.h
llvm::FunctionLoweringInfo::DA
const LegacyDivergenceAnalysis * DA
Definition: FunctionLoweringInfo.h:60
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::FunctionLoweringInfo::StatepointRelocationRecord::type
enum llvm::FunctionLoweringInfo::StatepointRelocationRecord::RelocType type
TargetRegisterInfo.h
llvm::FunctionLoweringInfo::CreateReg
Register CreateReg(MVT VT, bool isDivergent=false)
CreateReg - Allocate a single virtual register for the given type.
Definition: FunctionLoweringInfo.cpp:374
llvm::FunctionLoweringInfo::RegInfo
MachineRegisterInfo * RegInfo
Definition: FunctionLoweringInfo.h:58
llvm::codeview::PublicSymFlags::Function
@ Function
llvm::FunctionLoweringInfo::getCatchPadExceptionPointerVReg
Register getCatchPadExceptionPointerVReg(const Value *CPI, const TargetRegisterClass *RC)
Definition: FunctionLoweringInfo.cpp:540
llvm::FunctionLoweringInfo::PreferredExtendType
DenseMap< const Value *, ISD::NodeType > PreferredExtendType
Record the preferred extend type (ISD::SIGN_EXTEND or ISD::ZERO_EXTEND) for a value.
Definition: FunctionLoweringInfo.h:165