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"
18using namespace llvm;
19
20MDString *MDBuilder::createString(StringRef Str) {
21  return MDString::get(Context, Str);
22}
23
24ConstantAsMetadata *MDBuilder::createConstant(Constant *C) {
25  return ConstantAsMetadata::get(C);
26}
27
28MDNode *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
37MDNode *MDBuilder::createBranchWeights(uint32_t TrueWeight,
38                                       uint32_t FalseWeight) {
39  return createBranchWeights({TrueWeight, FalseWeight});
40}
41
42MDNode *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
55MDNode *MDBuilder::createUnpredictable() {
56  return MDNode::get(Context, std::nullopt);
57}
58
59MDNode *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
78MDNode *MDBuilder::createFunctionSectionPrefix(StringRef Prefix) {
79  return MDNode::get(Context,
80                     {createString("function_section_prefix"),
81                      createString(Prefix)});
82}
83
84MDNode *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
91MDNode *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
100MDNode *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
107MDNode *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
124MDNode *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
153MDNode *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
161MDNode *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
182MDNode *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
200MDNode *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'.
206MDNode *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
216MDNode *MDBuilder::createAliasScopeDomain(StringRef Name) {
217  return MDNode::get(Context, createString(Name));
218}
219
220MDNode *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.
226MDNode *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).
239MDNode *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.
253MDNode *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.
262MDNode *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
273MDNode *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
289MDNode *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
303MDNode *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
330MDNode *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
338MDNode *MDBuilder::createPseudoProbeDesc(uint64_t GUID, uint64_t Hash,
339                                         StringRef FName) {
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(FName);
345  return MDNode::get(Context, Ops);
346}
347
348MDNode *
349MDBuilder::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