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/SmallPtrSet.h"
21 #include "llvm/ADT/SmallVector.h"
25 #include "llvm/IR/Instructions.h"
26 #include "llvm/IR/Type.h"
27 #include "llvm/IR/Value.h"
28 #include "llvm/Support/KnownBits.h"
29 #include <cassert>
30 #include <utility>
31 #include <vector>
32 
33 namespace llvm {
34 
35 class Argument;
36 class BasicBlock;
37 class BranchProbabilityInfo;
38 class LegacyDivergenceAnalysis;
39 class Function;
40 class Instruction;
41 class MachineFunction;
42 class MachineInstr;
43 class MachineRegisterInfo;
44 class MVT;
45 class SelectionDAG;
46 class TargetLowering;
47 
48 //===--------------------------------------------------------------------===//
49 /// FunctionLoweringInfo - This contains information that is global to a
50 /// function that is used when lowering a region of the function.
51 ///
53 public:
54  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.
70 
71  /// MBBMap - A mapping from LLVM basic blocks to their machine code entry.
73 
74  /// ValueMap - Since we emit code for the function a basic block at a time,
75  /// we must remember which virtual registers hold the values for
76  /// cross-basic-block values.
78 
79  /// VirtReg2Value map is needed by the Divergence Analysis driven
80  /// instruction selection. It is reverted ValueMap. It is computed
81  /// in lazy style - on demand. It is used to get the Value corresponding
82  /// to the live in virtual register and is called from the
83  /// TargetLowerinInfo::isSDNodeSourceOfDivergence.
85 
86  /// This method is called from TargetLowerinInfo::isSDNodeSourceOfDivergence
87  /// to get the Value corresponding to the live-in virtual register.
89 
90  /// Track virtual registers created for exception pointers.
92 
93  /// Helper object to track which of three possible relocation mechanisms are
94  /// used for a particular value being relocated over a statepoint.
96  enum RelocType {
97  // Value did not need to be relocated and can be used directly.
99  // Value was spilled to stack and needs filled at the gc.relocate.
101  // Value was lowered to tied def and gc.relocate should be replaced with
102  // copy from vreg.
104  } type = NoRelocate;
105  // Payload contains either frame index of the stack slot in which the value
106  // was spilled, or virtual register which contains the re-definition.
107  union payload_t {
108  payload_t() : FI(-1) {}
109  int FI;
111  } payload;
112  };
113 
114  /// Keep track of each value which was relocated and the strategy used to
115  /// relocate that value. This information is required when visiting
116  /// gc.relocates which may appear in following blocks.
117  using StatepointSpillMapTy =
120 
121  /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in
122  /// the entry block. This allows the allocas to be efficiently referenced
123  /// anywhere in the function.
125 
126  /// ByValArgFrameIndexMap - Keep track of frame indices for byval arguments.
128 
129  /// ArgDbgValues - A list of DBG_VALUE instructions created during isel for
130  /// function arguments that are inserted after scheduling is completed.
132 
133  /// Bitvector with a bit set if corresponding argument is described in
134  /// ArgDbgValues. Using arg numbers according to Argument numbering.
136 
137  /// RegFixups - Registers which need to be replaced after isel is done.
139 
141 
142  /// StatepointStackSlots - A list of temporary stack slots (frame indices)
143  /// used to spill values at a statepoint. We store them here to enable
144  /// reuse of the same stack slots across different statepoints in different
145  /// basic blocks.
147 
148  /// MBB - The current block.
150 
151  /// MBB - The current insert position inside the current block.
153 
154  struct LiveOutInfo {
155  unsigned NumSignBits : 31;
156  unsigned IsValid : 1;
158 
160  };
161 
162  /// Record the preferred extend type (ISD::SIGN_EXTEND or ISD::ZERO_EXTEND)
163  /// for a value.
165 
166  /// VisitedBBs - The set of basic blocks visited thus far by instruction
167  /// selection.
169 
170  /// PHINodesToUpdate - A list of phi instructions whose operand list will
171  /// be updated after processing the current basic block.
172  /// TODO: This isn't per-function state, it's per-basic-block state. But
173  /// there's no other convenient place for it to live right now.
174  std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate;
176 
177  /// If the current MBB is a landing pad, the exception pointer and exception
178  /// selector registers are copied into these virtual registers by
179  /// SelectionDAGISel::PrepareEHLandingPad().
181 
182  /// set - Initialize this FunctionLoweringInfo with the given Function
183  /// and its associated MachineFunction.
184  ///
185  void set(const Function &Fn, MachineFunction &MF, SelectionDAG *DAG);
186 
187  /// clear - Clear out all the function-specific state. This returns this
188  /// FunctionLoweringInfo to an empty state, ready to be used for a
189  /// different function.
190  void clear();
191 
192  /// isExportedInst - Return true if the specified value is an instruction
193  /// exported from its block.
194  bool isExportedInst(const Value *V) const {
195  return ValueMap.count(V);
196  }
197 
198  Register CreateReg(MVT VT, bool isDivergent = false);
199 
200  Register CreateRegs(const Value *V);
201 
202  Register CreateRegs(Type *Ty, bool isDivergent = false);
203 
205  // Tokens never live in vregs.
206  if (V->getType()->isTokenTy())
207  return 0;
208  Register &R = ValueMap[V];
209  assert(R == 0 && "Already initialized this value register!");
210  assert(VirtReg2Value.empty());
211  return R = CreateRegs(V);
212  }
213 
214  /// GetLiveOutRegInfo - Gets LiveOutInfo for a register, returning NULL if the
215  /// register is a PHI destination and the PHI's LiveOutInfo is not valid.
217  if (!LiveOutRegInfo.inBounds(Reg))
218  return nullptr;
219 
220  const LiveOutInfo *LOI = &LiveOutRegInfo[Reg];
221  if (!LOI->IsValid)
222  return nullptr;
223 
224  return LOI;
225  }
226 
227  /// GetLiveOutRegInfo - Gets LiveOutInfo for a register, returning NULL if the
228  /// register is a PHI destination and the PHI's LiveOutInfo is not valid. If
229  /// the register's LiveOutInfo is for a smaller bit width, it is extended to
230  /// the larger bit width by zero extension. The bit width must be no smaller
231  /// than the LiveOutInfo's existing bit width.
232  const LiveOutInfo *GetLiveOutRegInfo(Register Reg, unsigned BitWidth);
233 
234  /// AddLiveOutRegInfo - Adds LiveOutInfo for a register.
235  void AddLiveOutRegInfo(Register Reg, unsigned NumSignBits,
236  const KnownBits &Known) {
237  // Only install this information if it tells us something.
238  if (NumSignBits == 1 && Known.isUnknown())
239  return;
240 
241  LiveOutRegInfo.grow(Reg);
242  LiveOutInfo &LOI = LiveOutRegInfo[Reg];
243  LOI.NumSignBits = NumSignBits;
244  LOI.Known.One = Known.One;
245  LOI.Known.Zero = Known.Zero;
246  }
247 
248  /// ComputePHILiveOutRegInfo - Compute LiveOutInfo for a PHI's destination
249  /// register based on the LiveOutInfo of its operands.
250  void ComputePHILiveOutRegInfo(const PHINode*);
251 
252  /// InvalidatePHILiveOutRegInfo - Invalidates a PHI's LiveOutInfo, to be
253  /// called when a block is visited before all of its predecessors.
255  // PHIs with no uses have no ValueMap entry.
257  if (It == ValueMap.end())
258  return;
259 
260  Register Reg = It->second;
261  if (Reg == 0)
262  return;
263 
264  LiveOutRegInfo.grow(Reg);
265  LiveOutRegInfo[Reg].IsValid = false;
266  }
267 
268  /// setArgumentFrameIndex - Record frame index for the byval
269  /// argument.
270  void setArgumentFrameIndex(const Argument *A, int FI);
271 
272  /// getArgumentFrameIndex - Get frame index for the byval argument.
273  int getArgumentFrameIndex(const Argument *A);
274 
276  const TargetRegisterClass *RC);
277 
278 private:
279  /// LiveOutRegInfo - Information about live out vregs.
281 };
282 
283 } // end namespace llvm
284 
285 #endif // LLVM_CODEGEN_FUNCTIONLOWERINGINFO_H
llvm::FunctionLoweringInfo::Fn
const Function * Fn
Definition: FunctionLoweringInfo.h:54
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:124
IndexedMap.h
llvm::FunctionLoweringInfo::StatepointRelocationRecord::payload_t::payload_t
payload_t()
Definition: FunctionLoweringInfo.h:108
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
Reg
unsigned Reg
Definition: MachineSink.cpp:1566
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:235
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:180
llvm::FunctionLoweringInfo::ExceptionSelectorVirtReg
unsigned ExceptionSelectorVirtReg
Definition: FunctionLoweringInfo.h:180
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:62
llvm::FunctionLoweringInfo::LiveOutInfo
Definition: FunctionLoweringInfo.h:154
llvm::FunctionLoweringInfo::InsertPt
MachineBasicBlock::iterator InsertPt
MBB - The current insert position inside the current block.
Definition: FunctionLoweringInfo.h:152
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:95
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:140
llvm::FunctionLoweringInfo::StatepointRelocationRecord::payload_t
Definition: FunctionLoweringInfo.h:107
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:149
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:194
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:77
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:135
llvm::FunctionLoweringInfo::CanLowerReturn
bool CanLowerReturn
CanLowerReturn - true iff the function's return value can be lowered to registers.
Definition: FunctionLoweringInfo.h:62
llvm::FunctionLoweringInfo::StatepointRelocationRecord::VReg
@ VReg
Definition: FunctionLoweringInfo.h:103
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:146
llvm::FunctionLoweringInfo::DemoteRegister
Register DemoteRegister
DemoteRegister - if CanLowerReturn is false, DemoteRegister is a vreg allocated to hold a pointer to ...
Definition: FunctionLoweringInfo.h:69
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:72
llvm::FunctionLoweringInfo::LiveOutInfo::LiveOutInfo
LiveOutInfo()
Definition: FunctionLoweringInfo.h:159
llvm::TargetLowering
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
Definition: TargetLowering.h:3189
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:131
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:216
llvm::FunctionLoweringInfo::LiveOutInfo::NumSignBits
unsigned NumSignBits
Definition: FunctionLoweringInfo.h:155
llvm::Type::isTokenTy
bool isTokenTy() const
Return true if this is 'token'.
Definition: Type.h:187
BitVector.h
llvm::FunctionLoweringInfo::LiveOutInfo::Known
KnownBits Known
Definition: FunctionLoweringInfo.h:157
llvm::LegacyDivergenceAnalysis
Definition: LegacyDivergenceAnalysis.h:31
llvm::FunctionLoweringInfo::LiveOutInfo::IsValid
unsigned IsValid
Definition: FunctionLoweringInfo.h:156
llvm::FunctionLoweringInfo::BPI
BranchProbabilityInfo * BPI
Definition: FunctionLoweringInfo.h:58
SmallPtrSet.h
llvm::BitVector
Definition: BitVector.h:74
llvm::FunctionLoweringInfo::InitializeRegForValue
Register InitializeRegForValue(const Value *V)
Definition: FunctionLoweringInfo.h:204
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:175
Type.h
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
llvm::FunctionLoweringInfo::StatepointRelocationRecord::payload_t::Reg
Register Reg
Definition: FunctionLoweringInfo.h:110
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
llvm::FunctionLoweringInfo::TLI
const TargetLowering * TLI
Definition: FunctionLoweringInfo.h:56
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:65
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:52
llvm::FunctionLoweringInfo::CatchPadExceptionPointers
DenseMap< const Value *, Register > CatchPadExceptionPointers
Track virtual registers created for exception pointers.
Definition: FunctionLoweringInfo.h:91
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:127
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:119
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:168
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:254
llvm::KnownBits
Definition: KnownBits.h:23
llvm::FunctionLoweringInfo::StatepointRelocationRecord::Spill
@ Spill
Definition: FunctionLoweringInfo.h:100
llvm::FunctionLoweringInfo::StatepointRelocationRecord::payload_t::FI
int FI
Definition: FunctionLoweringInfo.h:109
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:138
llvm::FunctionLoweringInfo::StatepointRelocationRecord::NoRelocate
@ NoRelocate
Definition: FunctionLoweringInfo.h:98
Instructions.h
llvm::FunctionLoweringInfo::MF
MachineFunction * MF
Definition: FunctionLoweringInfo.h:55
SmallVector.h
llvm::FunctionLoweringInfo::VirtReg2Value
DenseMap< Register, const Value * > VirtReg2Value
VirtReg2Value map is needed by the Divergence Analysis driven instruction selection.
Definition: FunctionLoweringInfo.h:84
llvm::PHINode
Definition: Instructions.h:2633
llvm::FunctionLoweringInfo::StatepointRelocationRecord::RelocType
RelocType
Definition: FunctionLoweringInfo.h:96
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:174
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:1903
llvm::MachineInstrBundleIterator< MachineInstr >
Value.h
llvm::FunctionLoweringInfo::DA
const LegacyDivergenceAnalysis * DA
Definition: FunctionLoweringInfo.h:59
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:57
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:164