LLVM  16.0.0git
MDBuilder.cpp
Go to the documentation of this file.
1 //===---- llvm/MDBuilder.cpp - Builder for LLVM metadata ------------------===//
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 file defines the MDBuilder class, which is used as a convenient way to
10 // create LLVM metadata with a consistent and simplified interface.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/IR/MDBuilder.h"
15 #include "llvm/IR/Constants.h"
16 #include "llvm/IR/Function.h"
17 #include "llvm/IR/Metadata.h"
18 using namespace llvm;
19 
21  return MDString::get(Context, Str);
22 }
23 
25  return ConstantAsMetadata::get(C);
26 }
27 
28 MDNode *MDBuilder::createFPMath(float Accuracy) {
29  if (Accuracy == 0.0)
30  return nullptr;
31  assert(Accuracy > 0.0 && "Invalid fpmath accuracy!");
32  auto *Op =
33  createConstant(ConstantFP::get(Type::getFloatTy(Context), Accuracy));
34  return MDNode::get(Context, Op);
35 }
36 
38  uint32_t FalseWeight) {
39  return createBranchWeights({TrueWeight, FalseWeight});
40 }
41 
43  assert(Weights.size() >= 1 && "Need at least one branch weights!");
44 
45  SmallVector<Metadata *, 4> Vals(Weights.size() + 1);
46  Vals[0] = createString("branch_weights");
47 
48  Type *Int32Ty = Type::getInt32Ty(Context);
49  for (unsigned i = 0, e = Weights.size(); i != e; ++i)
50  Vals[i + 1] = createConstant(ConstantInt::get(Int32Ty, Weights[i]));
51 
52  return MDNode::get(Context, Vals);
53 }
54 
56  return MDNode::get(Context, None);
57 }
58 
60  uint64_t Count, bool Synthetic,
61  const DenseSet<GlobalValue::GUID> *Imports) {
62  Type *Int64Ty = Type::getInt64Ty(Context);
64  if (Synthetic)
65  Ops.push_back(createString("synthetic_function_entry_count"));
66  else
67  Ops.push_back(createString("function_entry_count"));
68  Ops.push_back(createConstant(ConstantInt::get(Int64Ty, Count)));
69  if (Imports) {
70  SmallVector<GlobalValue::GUID, 2> OrderID(Imports->begin(), Imports->end());
71  llvm::sort(OrderID);
72  for (auto ID : OrderID)
73  Ops.push_back(createConstant(ConstantInt::get(Int64Ty, ID)));
74  }
75  return MDNode::get(Context, Ops);
76 }
77 
79  return MDNode::get(Context,
80  {createString("function_section_prefix"),
82 }
83 
84 MDNode *MDBuilder::createRange(const APInt &Lo, const APInt &Hi) {
85  assert(Lo.getBitWidth() == Hi.getBitWidth() && "Mismatched bitwidths!");
86 
87  Type *Ty = IntegerType::get(Context, Lo.getBitWidth());
88  return createRange(ConstantInt::get(Ty, Lo), ConstantInt::get(Ty, Hi));
89 }
90 
92  // If the range is everything then it is useless.
93  if (Hi == Lo)
94  return nullptr;
95 
96  // Return the range [Lo, Hi).
97  return MDNode::get(Context, {createConstant(Lo), createConstant(Hi)});
98 }
99 
102  for (Function *F : Callees)
103  Ops.push_back(createConstant(F));
104  return MDNode::get(Context, Ops);
105 }
106 
109  bool VarArgArePassed) {
111 
112  Type *Int64 = Type::getInt64Ty(Context);
113  Ops.push_back(createConstant(ConstantInt::get(Int64, CalleeArgNo)));
114 
115  for (int ArgNo : Arguments)
116  Ops.push_back(createConstant(ConstantInt::get(Int64, ArgNo, true)));
117 
118  Type *Int1 = Type::getInt1Ty(Context);
119  Ops.push_back(createConstant(ConstantInt::get(Int1, VarArgArePassed)));
120 
121  return MDNode::get(Context, Ops);
122 }
123 
125  MDNode *NewCB) {
126  if (!ExistingCallbacks)
127  return MDNode::get(Context, {NewCB});
128 
129  auto *NewCBCalleeIdxAsCM = cast<ConstantAsMetadata>(NewCB->getOperand(0));
130  uint64_t NewCBCalleeIdx =
131  cast<ConstantInt>(NewCBCalleeIdxAsCM->getValue())->getZExtValue();
132  (void)NewCBCalleeIdx;
133 
135  unsigned NumExistingOps = ExistingCallbacks->getNumOperands();
136  Ops.resize(NumExistingOps + 1);
137 
138  for (unsigned u = 0; u < NumExistingOps; u++) {
139  Ops[u] = ExistingCallbacks->getOperand(u);
140 
141  auto *OldCBCalleeIdxAsCM = cast<ConstantAsMetadata>(Ops[u]);
142  uint64_t OldCBCalleeIdx =
143  cast<ConstantInt>(OldCBCalleeIdxAsCM->getValue())->getZExtValue();
144  (void)OldCBCalleeIdx;
145  assert(NewCBCalleeIdx != OldCBCalleeIdx &&
146  "Cannot map a callback callee index twice!");
147  }
148 
149  Ops[NumExistingOps] = NewCB;
150  return MDNode::get(Context, Ops);
151 }
152 
154  Constant *RTTI) {
156  Ops.push_back(createConstant(PrologueSig));
157  Ops.push_back(createConstant(RTTI));
158  return MDNode::get(Context, Ops);
159 }
160 
163 
164  for (const auto &Entry : Sections) {
165  const StringRef &Sec = Entry.first;
166  Ops.push_back(createString(Sec));
167 
168  // If auxiliary data for this section exists, append it.
169  const SmallVector<Constant *> &AuxConsts = Entry.second;
170  if (!AuxConsts.empty()) {
172  AuxMDs.reserve(AuxConsts.size());
173  for (Constant *C : AuxConsts)
174  AuxMDs.push_back(createConstant(C));
175  Ops.push_back(MDNode::get(Context, AuxMDs));
176  }
177  }
178 
179  return MDNode::get(Context, Ops);
180 }
181 
183  SmallVector<Metadata *, 3> Args(1, nullptr);
184  if (Extra)
185  Args.push_back(Extra);
186  if (!Name.empty())
187  Args.push_back(createString(Name));
188  MDNode *Root = MDNode::getDistinct(Context, Args);
189 
190  // At this point we have
191  // !0 = distinct !{null} <- root
192  // Replace the reserved operand with the root node itself.
193  Root->replaceOperandWith(0, Root);
194 
195  // We now have
196  // !0 = distinct !{!0} <- root
197  return Root;
198 }
199 
201  return MDNode::get(Context, createString(Name));
202 }
203 
204 /// Return metadata for a non-root TBAA node with the given name,
205 /// parent in the TBAA tree, and value for 'pointsToConstantMemory'.
207  bool isConstant) {
208  if (isConstant) {
209  Constant *Flags = ConstantInt::get(Type::getInt64Ty(Context), 1);
210  return MDNode::get(Context,
211  {createString(Name), Parent, createConstant(Flags)});
212  }
213  return MDNode::get(Context, {createString(Name), Parent});
214 }
215 
217  return MDNode::get(Context, createString(Name));
218 }
219 
221  return MDNode::get(Context, {createString(Name), Domain});
222 }
223 
224 /// Return metadata for a tbaa.struct node with the given
225 /// struct field descriptions.
227  SmallVector<Metadata *, 4> Vals(Fields.size() * 3);
228  Type *Int64 = Type::getInt64Ty(Context);
229  for (unsigned i = 0, e = Fields.size(); i != e; ++i) {
230  Vals[i * 3 + 0] = createConstant(ConstantInt::get(Int64, Fields[i].Offset));
231  Vals[i * 3 + 1] = createConstant(ConstantInt::get(Int64, Fields[i].Size));
232  Vals[i * 3 + 2] = Fields[i].Type;
233  }
234  return MDNode::get(Context, Vals);
235 }
236 
237 /// Return metadata for a TBAA struct node in the type DAG
238 /// with the given name, a list of pairs (offset, field type in the type DAG).
240  StringRef Name, ArrayRef<std::pair<MDNode *, uint64_t>> Fields) {
241  SmallVector<Metadata *, 4> Ops(Fields.size() * 2 + 1);
242  Type *Int64 = Type::getInt64Ty(Context);
243  Ops[0] = createString(Name);
244  for (unsigned i = 0, e = Fields.size(); i != e; ++i) {
245  Ops[i * 2 + 1] = Fields[i].first;
246  Ops[i * 2 + 2] = createConstant(ConstantInt::get(Int64, Fields[i].second));
247  }
248  return MDNode::get(Context, Ops);
249 }
250 
251 /// Return metadata for a TBAA scalar type node with the
252 /// given name, an offset and a parent in the TBAA type DAG.
254  uint64_t Offset) {
255  ConstantInt *Off = ConstantInt::get(Type::getInt64Ty(Context), Offset);
256  return MDNode::get(Context,
257  {createString(Name), Parent, createConstant(Off)});
258 }
259 
260 /// Return metadata for a TBAA tag node with the given
261 /// base type, access type and offset relative to the base type.
263  uint64_t Offset, bool IsConstant) {
264  IntegerType *Int64 = Type::getInt64Ty(Context);
265  ConstantInt *Off = ConstantInt::get(Int64, Offset);
266  if (IsConstant) {
267  return MDNode::get(Context, {BaseType, AccessType, createConstant(Off),
268  createConstant(ConstantInt::get(Int64, 1))});
269  }
270  return MDNode::get(Context, {BaseType, AccessType, createConstant(Off)});
271 }
272 
274  Metadata *Id,
275  ArrayRef<TBAAStructField> Fields) {
276  SmallVector<Metadata *, 4> Ops(3 + Fields.size() * 3);
277  Type *Int64 = Type::getInt64Ty(Context);
278  Ops[0] = Parent;
279  Ops[1] = createConstant(ConstantInt::get(Int64, Size));
280  Ops[2] = Id;
281  for (unsigned I = 0, E = Fields.size(); I != E; ++I) {
282  Ops[I * 3 + 3] = Fields[I].Type;
283  Ops[I * 3 + 4] = createConstant(ConstantInt::get(Int64, Fields[I].Offset));
284  Ops[I * 3 + 5] = createConstant(ConstantInt::get(Int64, Fields[I].Size));
285  }
286  return MDNode::get(Context, Ops);
287 }
288 
290  uint64_t Offset, uint64_t Size,
291  bool IsImmutable) {
292  IntegerType *Int64 = Type::getInt64Ty(Context);
293  auto *OffsetNode = createConstant(ConstantInt::get(Int64, Offset));
294  auto *SizeNode = createConstant(ConstantInt::get(Int64, Size));
295  if (IsImmutable) {
296  auto *ImmutabilityFlagNode = createConstant(ConstantInt::get(Int64, 1));
297  return MDNode::get(Context, {BaseType, AccessType, OffsetNode, SizeNode,
298  ImmutabilityFlagNode});
299  }
300  return MDNode::get(Context, {BaseType, AccessType, OffsetNode, SizeNode});
301 }
302 
304  MDNode *BaseType = cast<MDNode>(Tag->getOperand(0));
305  MDNode *AccessType = cast<MDNode>(Tag->getOperand(1));
306  Metadata *OffsetNode = Tag->getOperand(2);
307  uint64_t Offset = mdconst::extract<ConstantInt>(OffsetNode)->getZExtValue();
308 
309  bool NewFormat = isa<MDNode>(AccessType->getOperand(0));
310 
311  // See if the tag is already mutable.
312  unsigned ImmutabilityFlagOp = NewFormat ? 4 : 3;
313  if (Tag->getNumOperands() <= ImmutabilityFlagOp)
314  return Tag;
315 
316  // If Tag is already mutable then return it.
317  Metadata *ImmutabilityFlagNode = Tag->getOperand(ImmutabilityFlagOp);
318  if (!mdconst::extract<ConstantInt>(ImmutabilityFlagNode)->getValue())
319  return Tag;
320 
321  // Otherwise, create another node.
322  if (!NewFormat)
323  return createTBAAStructTagNode(BaseType, AccessType, Offset);
324 
325  Metadata *SizeNode = Tag->getOperand(3);
326  uint64_t Size = mdconst::extract<ConstantInt>(SizeNode)->getZExtValue();
327  return createTBAAAccessTag(BaseType, AccessType, Offset, Size);
328 }
329 
331  Metadata *Vals[] = {
332  createString("loop_header_weight"),
334  };
335  return MDNode::get(Context, Vals);
336 }
337 
339  Function *F) {
340  auto *Int64Ty = Type::getInt64Ty(Context);
342  Ops[0] = createConstant(ConstantInt::get(Int64Ty, GUID));
343  Ops[1] = createConstant(ConstantInt::get(Int64Ty, Hash));
344  Ops[2] = createString(F->getName());
345  return MDNode::get(Context, Ops);
346 }
i
i
Definition: README.txt:29
Int32Ty
IntegerType * Int32Ty
Definition: NVVMIntrRange.cpp:67
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::MDBuilder::createConstant
ConstantAsMetadata * createConstant(Constant *C)
Return the given constant as metadata.
Definition: MDBuilder.cpp:24
llvm::MDBuilder::createMutableTBAAAccessTag
MDNode * createMutableTBAAAccessTag(MDNode *Tag)
Return mutable version of the given mutable or immutable TBAA access tag.
Definition: MDBuilder.cpp:303
llvm::Type::getInt1Ty
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:236
llvm::MDBuilder::createTBAAStructTypeNode
MDNode * createTBAAStructTypeNode(StringRef Name, ArrayRef< std::pair< MDNode *, uint64_t >> Fields)
Return metadata for a TBAA struct node in the type DAG with the given name, a list of pairs (offset,...
Definition: MDBuilder.cpp:239
llvm::MDBuilder::createFPMath
MDNode * createFPMath(float Accuracy)
Return metadata with the given settings.
Definition: MDBuilder.cpp:28
Metadata.h
llvm::MDBuilder::createAliasScopeDomain
MDNode * createAliasScopeDomain(StringRef Name)
Return metadata appropriate for an alias scope domain node with the given name.
Definition: MDBuilder.cpp:216
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:161
llvm::Function
Definition: Function.h:60
llvm::MDBuilder::createPseudoProbeDesc
MDNode * createPseudoProbeDesc(uint64_t GUID, uint64_t Hash, Function *F)
Return metadata containing the pseudo probe descriptor for a function.
Definition: MDBuilder.cpp:338
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1181
llvm::MDBuilder::createAliasScope
MDNode * createAliasScope(StringRef Name, MDNode *Domain)
Return metadata appropriate for an alias scope node with the given name.
Definition: MDBuilder.cpp:220
llvm::MDBuilder::createUnpredictable
MDNode * createUnpredictable()
Return metadata specifying that a branch or switch is unpredictable.
Definition: MDBuilder.cpp:55
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::ConstantAsMetadata::get
static ConstantAsMetadata * get(Constant *C)
Definition: Metadata.h:420
llvm::dwarf::Tag
Tag
Definition: Dwarf.h:105
BaseType
llvm::Type::getInt32Ty
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:239
llvm::MDNode::get
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1400
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::MDNode::getNumOperands
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1298
llvm::detail::DenseSetImpl< ValueT, DenseMap< ValueT, detail::DenseSetEmpty, DenseMapInfo< ValueT >, detail::DenseSetPair< ValueT > >, DenseMapInfo< ValueT > >::end
iterator end()
Definition: DenseSet.h:174
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
Constants.h
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::MDBuilder::createBranchWeights
MDNode * createBranchWeights(uint32_t TrueWeight, uint32_t FalseWeight)
Return metadata containing two branch weights.
Definition: MDBuilder.cpp:37
llvm::MDBuilder::createTBAANode
MDNode * createTBAANode(StringRef Name, MDNode *Parent, bool isConstant=false)
Return metadata for a non-root TBAA node with the given name, parent in the TBAA tree,...
Definition: MDBuilder.cpp:206
Domain
Domain
Definition: CorrelatedValuePropagation.cpp:710
llvm::IntegerType
Class to represent integer types.
Definition: DerivedTypes.h:40
MDBuilder.h
llvm::SmallVectorImpl::resize
void resize(size_type N)
Definition: SmallVector.h:624
llvm::ConstantInt::get
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:879
llvm::MDBuilder::createTBAAStructTagNode
MDNode * createTBAAStructTagNode(MDNode *BaseType, MDNode *AccessType, uint64_t Offset, bool IsConstant=false)
Return metadata for a TBAA tag node with the given base type, access type and offset relative to the ...
Definition: MDBuilder.cpp:262
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::None
const NoneType None
Definition: None.h:24
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
llvm::MDBuilder::mergeCallbackEncodings
MDNode * mergeCallbackEncodings(MDNode *ExistingCallbacks, MDNode *NewCB)
Merge the new callback encoding NewCB into ExistingCallbacks.
Definition: MDBuilder.cpp:124
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1538
llvm::MDNode::getOperand
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1292
llvm::MDBuilder::createString
MDString * createString(StringRef Str)
Return the given string as metadata.
Definition: MDBuilder.cpp:20
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
llvm::MDBuilder::createPCSections
MDNode * createPCSections(ArrayRef< PCSection > Sections)
Return metadata for PC sections.
Definition: MDBuilder.cpp:161
BaseType
BaseType
A given derived pointer can have multiple base pointers through phi/selects.
Definition: SafepointIRVerifier.cpp:314
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
uint64_t
isConstant
static bool isConstant(const MachineInstr &MI)
Definition: AMDGPUInstructionSelector.cpp:2385
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:53
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::MDString::get
static MDString * get(LLVMContext &Context, StringRef Str)
Definition: Metadata.cpp:498
llvm::detail::DenseSetImpl< ValueT, DenseMap< ValueT, detail::DenseSetEmpty, DenseMapInfo< ValueT >, detail::DenseSetPair< ValueT > >, DenseMapInfo< ValueT > >::begin
iterator begin()
Definition: DenseSet.h:173
llvm::MDBuilder::createTBAAAccessTag
MDNode * createTBAAAccessTag(MDNode *BaseType, MDNode *AccessType, uint64_t Offset, uint64_t Size, bool IsImmutable=false)
Return metadata for a TBAA access tag with the given base type, final access type,...
Definition: MDBuilder.cpp:289
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::MDBuilder::createCallbackEncoding
MDNode * createCallbackEncoding(unsigned CalleeArgNo, ArrayRef< int > Arguments, bool VarArgsArePassed)
Return metadata describing a callback (see llvm::AbstractCallSite).
Definition: MDBuilder.cpp:107
llvm::MDNode
Metadata node.
Definition: Metadata.h:944
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
llvm::ArrayRef< uint32_t >
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
uint32_t
llvm::MDNode::getDistinct
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1408
llvm::MDBuilder::createFunctionSectionPrefix
MDNode * createFunctionSectionPrefix(StringRef Prefix)
Return metadata containing the section prefix for a function.
Definition: MDBuilder.cpp:78
llvm::MDBuilder::createAnonymousAARoot
MDNode * createAnonymousAARoot(StringRef Name=StringRef(), MDNode *Extra=nullptr)
Return metadata appropriate for a AA root node (scope or TBAA).
Definition: MDBuilder.cpp:182
llvm::ConstantAsMetadata
Definition: Metadata.h:413
llvm::MDBuilder::createTBAAStructNode
MDNode * createTBAAStructNode(ArrayRef< TBAAStructField > Fields)
Return metadata for a tbaa.struct node with the given struct field descriptions.
Definition: MDBuilder.cpp:226
llvm::Type::getInt64Ty
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:240
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:348
llvm::ConstantFP::get
static Constant * get(Type *Ty, double V)
This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in...
Definition: Constants.cpp:926
Function.h
Arguments
AMDGPU Lower Kernel Arguments
Definition: AMDGPULowerKernelArguments.cpp:242
llvm::MDBuilder::createTBAAScalarTypeNode
MDNode * createTBAAScalarTypeNode(StringRef Name, MDNode *Parent, uint64_t Offset=0)
Return metadata for a TBAA scalar type node with the given name, an offset and a parent in the TBAA t...
Definition: MDBuilder.cpp:253
llvm::MDNode::replaceOperandWith
void replaceOperandWith(unsigned I, Metadata *New)
Replace a specific operand.
Definition: Metadata.cpp:969
llvm::MDBuilder::createTBAARoot
MDNode * createTBAARoot(StringRef Name)
Return metadata appropriate for a TBAA root node with the given name.
Definition: MDBuilder.cpp:200
llvm::MDBuilder::createCallees
MDNode * createCallees(ArrayRef< Function * > Callees)
Return metadata indicating the possible callees of indirect calls.
Definition: MDBuilder.cpp:100
llvm::MDBuilder::createRange
MDNode * createRange(const APInt &Lo, const APInt &Hi)
Return metadata describing the range [Lo, Hi).
Definition: MDBuilder.cpp:84
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:164
llvm::IntegerType::get
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:311
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:394
llvm::MDBuilder::createTBAATypeNode
MDNode * createTBAATypeNode(MDNode *Parent, uint64_t Size, Metadata *Id, ArrayRef< TBAAStructField > Fields=ArrayRef< TBAAStructField >())
Return metadata for a TBAA type node in the TBAA type DAG with the given parent type,...
Definition: MDBuilder.cpp:273
llvm::AMDGPU::VGPRIndexMode::Id
Id
Definition: SIDefines.h:241
llvm::MDBuilder::createRTTIPointerPrologue
MDNode * createRTTIPointerPrologue(Constant *PrologueSig, Constant *RTTI)
Return metadata feeding to the CodeGen about how to generate a function prologue for the "function" s...
Definition: MDBuilder.cpp:153
llvm::SmallVectorImpl::reserve
void reserve(size_type N)
Definition: SmallVector.h:649
llvm::MDString
A single uniqued string.
Definition: Metadata.h:612
llvm::MDBuilder::createFunctionEntryCount
MDNode * createFunctionEntryCount(uint64_t Count, bool Synthetic, const DenseSet< GlobalValue::GUID > *Imports)
Return metadata containing the entry Count for a function, a boolean \Synthetic indicating whether th...
Definition: MDBuilder.cpp:59
llvm::Type::getFloatTy
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:226
llvm::MDBuilder::createIrrLoopHeaderWeight
MDNode * createIrrLoopHeaderWeight(uint64_t Weight)
Return metadata containing an irreducible loop header weight.
Definition: MDBuilder.cpp:330