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
createString(StringRef Str)20 MDString *MDBuilder::createString(StringRef Str) {
21 return MDString::get(Context, Str);
22 }
23
createConstant(Constant * C)24 ConstantAsMetadata *MDBuilder::createConstant(Constant *C) {
25 return ConstantAsMetadata::get(C);
26 }
27
createFPMath(float Accuracy)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
createBranchWeights(uint32_t TrueWeight,uint32_t FalseWeight)37 MDNode *MDBuilder::createBranchWeights(uint32_t TrueWeight,
38 uint32_t FalseWeight) {
39 return createBranchWeights({TrueWeight, FalseWeight});
40 }
41
createBranchWeights(ArrayRef<uint32_t> Weights)42 MDNode *MDBuilder::createBranchWeights(ArrayRef<uint32_t> Weights) {
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
createUnpredictable()55 MDNode *MDBuilder::createUnpredictable() {
56 return MDNode::get(Context, std::nullopt);
57 }
58
createFunctionEntryCount(uint64_t Count,bool Synthetic,const DenseSet<GlobalValue::GUID> * Imports)59 MDNode *MDBuilder::createFunctionEntryCount(
60 uint64_t Count, bool Synthetic,
61 const DenseSet<GlobalValue::GUID> *Imports) {
62 Type *Int64Ty = Type::getInt64Ty(Context);
63 SmallVector<Metadata *, 8> Ops;
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
createFunctionSectionPrefix(StringRef Prefix)78 MDNode *MDBuilder::createFunctionSectionPrefix(StringRef Prefix) {
79 return MDNode::get(Context,
80 {createString("function_section_prefix"),
81 createString(Prefix)});
82 }
83
createRange(const APInt & Lo,const APInt & Hi)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
createRange(Constant * Lo,Constant * Hi)91 MDNode *MDBuilder::createRange(Constant *Lo, Constant *Hi) {
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
createCallees(ArrayRef<Function * > Callees)100 MDNode *MDBuilder::createCallees(ArrayRef<Function *> Callees) {
101 SmallVector<Metadata *, 4> Ops;
102 for (Function *F : Callees)
103 Ops.push_back(createConstant(F));
104 return MDNode::get(Context, Ops);
105 }
106
createCallbackEncoding(unsigned CalleeArgNo,ArrayRef<int> Arguments,bool VarArgArePassed)107 MDNode *MDBuilder::createCallbackEncoding(unsigned CalleeArgNo,
108 ArrayRef<int> Arguments,
109 bool VarArgArePassed) {
110 SmallVector<Metadata *, 4> Ops;
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
mergeCallbackEncodings(MDNode * ExistingCallbacks,MDNode * NewCB)124 MDNode *MDBuilder::mergeCallbackEncodings(MDNode *ExistingCallbacks,
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
134 SmallVector<Metadata *, 4> Ops;
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
createRTTIPointerPrologue(Constant * PrologueSig,Constant * RTTI)153 MDNode *MDBuilder::createRTTIPointerPrologue(Constant *PrologueSig,
154 Constant *RTTI) {
155 SmallVector<Metadata *, 4> Ops;
156 Ops.push_back(createConstant(PrologueSig));
157 Ops.push_back(createConstant(RTTI));
158 return MDNode::get(Context, Ops);
159 }
160
createPCSections(ArrayRef<PCSection> Sections)161 MDNode *MDBuilder::createPCSections(ArrayRef<PCSection> Sections) {
162 SmallVector<Metadata *, 2> Ops;
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()) {
171 SmallVector<Metadata *, 1> AuxMDs;
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
createAnonymousAARoot(StringRef Name,MDNode * Extra)182 MDNode *MDBuilder::createAnonymousAARoot(StringRef Name, MDNode *Extra) {
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
createTBAARoot(StringRef Name)200 MDNode *MDBuilder::createTBAARoot(StringRef Name) {
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'.
createTBAANode(StringRef Name,MDNode * Parent,bool isConstant)206 MDNode *MDBuilder::createTBAANode(StringRef Name, MDNode *Parent,
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
createAliasScopeDomain(StringRef Name)216 MDNode *MDBuilder::createAliasScopeDomain(StringRef Name) {
217 return MDNode::get(Context, createString(Name));
218 }
219
createAliasScope(StringRef Name,MDNode * Domain)220 MDNode *MDBuilder::createAliasScope(StringRef Name, MDNode *Domain) {
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.
createTBAAStructNode(ArrayRef<TBAAStructField> Fields)226 MDNode *MDBuilder::createTBAAStructNode(ArrayRef<TBAAStructField> Fields) {
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).
createTBAAStructTypeNode(StringRef Name,ArrayRef<std::pair<MDNode *,uint64_t>> Fields)239 MDNode *MDBuilder::createTBAAStructTypeNode(
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.
createTBAAScalarTypeNode(StringRef Name,MDNode * Parent,uint64_t Offset)253 MDNode *MDBuilder::createTBAAScalarTypeNode(StringRef Name, MDNode *Parent,
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.
createTBAAStructTagNode(MDNode * BaseType,MDNode * AccessType,uint64_t Offset,bool IsConstant)262 MDNode *MDBuilder::createTBAAStructTagNode(MDNode *BaseType, MDNode *AccessType,
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
createTBAATypeNode(MDNode * Parent,uint64_t Size,Metadata * Id,ArrayRef<TBAAStructField> Fields)273 MDNode *MDBuilder::createTBAATypeNode(MDNode *Parent, uint64_t Size,
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
createTBAAAccessTag(MDNode * BaseType,MDNode * AccessType,uint64_t Offset,uint64_t Size,bool IsImmutable)289 MDNode *MDBuilder::createTBAAAccessTag(MDNode *BaseType, MDNode *AccessType,
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
createMutableTBAAAccessTag(MDNode * Tag)303 MDNode *MDBuilder::createMutableTBAAAccessTag(MDNode *Tag) {
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
createIrrLoopHeaderWeight(uint64_t Weight)330 MDNode *MDBuilder::createIrrLoopHeaderWeight(uint64_t Weight) {
331 Metadata *Vals[] = {
332 createString("loop_header_weight"),
333 createConstant(ConstantInt::get(Type::getInt64Ty(Context), Weight)),
334 };
335 return MDNode::get(Context, Vals);
336 }
337
createPseudoProbeDesc(uint64_t GUID,uint64_t Hash,Function * F)338 MDNode *MDBuilder::createPseudoProbeDesc(uint64_t GUID, uint64_t Hash,
339 Function *F) {
340 auto *Int64Ty = Type::getInt64Ty(Context);
341 SmallVector<Metadata *, 3> Ops(3);
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 }
347
348 MDNode *
createLLVMStats(ArrayRef<std::pair<StringRef,uint64_t>> LLVMStats)349 MDBuilder::createLLVMStats(ArrayRef<std::pair<StringRef, uint64_t>> LLVMStats) {
350 auto *Int64Ty = Type::getInt64Ty(Context);
351 SmallVector<Metadata *, 4> Ops(LLVMStats.size() * 2);
352 for (size_t I = 0; I < LLVMStats.size(); I++) {
353 Ops[I * 2] = createString(LLVMStats[I].first);
354 Ops[I * 2 + 1] =
355 createConstant(ConstantInt::get(Int64Ty, LLVMStats[I].second));
356 }
357 return MDNode::get(Context, Ops);
358 }
359