MDBuilder.cpp revision 360784 
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, None);
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::stable_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::createAnonymousAARoot(StringRef Name, MDNode *Extra) {
154  // To ensure uniqueness the root node is self-referential.
155  auto Dummy = MDNode::getTemporary(Context, None);
156
157  SmallVector<Metadata *, 3> Args(1, Dummy.get());
158  if (Extra)
159    Args.push_back(Extra);
160  if (!Name.empty())
161    Args.push_back(createString(Name));
162  MDNode *Root = MDNode::get(Context, Args);
163
164  // At this point we have
165  //   !0 = metadata !{}            <- dummy
166  //   !1 = metadata !{metadata !0} <- root
167  // Replace the dummy operand with the root node itself and delete the dummy.
168  Root->replaceOperandWith(0, Root);
169
170  // We now have
171  //   !1 = metadata !{metadata !1} <- self-referential root
172  return Root;
173}
174
175MDNode *MDBuilder::createTBAARoot(StringRef Name) {
176  return MDNode::get(Context, createString(Name));
177}
178
179/// Return metadata for a non-root TBAA node with the given name,
180/// parent in the TBAA tree, and value for 'pointsToConstantMemory'.
181MDNode *MDBuilder::createTBAANode(StringRef Name, MDNode *Parent,
182                                  bool isConstant) {
183  if (isConstant) {
184    Constant *Flags = ConstantInt::get(Type::getInt64Ty(Context), 1);
185    return MDNode::get(Context,
186                       {createString(Name), Parent, createConstant(Flags)});
187  }
188  return MDNode::get(Context, {createString(Name), Parent});
189}
190
191MDNode *MDBuilder::createAliasScopeDomain(StringRef Name) {
192  return MDNode::get(Context, createString(Name));
193}
194
195MDNode *MDBuilder::createAliasScope(StringRef Name, MDNode *Domain) {
196  return MDNode::get(Context, {createString(Name), Domain});
197}
198
199/// Return metadata for a tbaa.struct node with the given
200/// struct field descriptions.
201MDNode *MDBuilder::createTBAAStructNode(ArrayRef<TBAAStructField> Fields) {
202  SmallVector<Metadata *, 4> Vals(Fields.size() * 3);
203  Type *Int64 = Type::getInt64Ty(Context);
204  for (unsigned i = 0, e = Fields.size(); i != e; ++i) {
205    Vals[i * 3 + 0] = createConstant(ConstantInt::get(Int64, Fields[i].Offset));
206    Vals[i * 3 + 1] = createConstant(ConstantInt::get(Int64, Fields[i].Size));
207    Vals[i * 3 + 2] = Fields[i].Type;
208  }
209  return MDNode::get(Context, Vals);
210}
211
212/// Return metadata for a TBAA struct node in the type DAG
213/// with the given name, a list of pairs (offset, field type in the type DAG).
214MDNode *MDBuilder::createTBAAStructTypeNode(
215    StringRef Name, ArrayRef<std::pair<MDNode *, uint64_t>> Fields) {
216  SmallVector<Metadata *, 4> Ops(Fields.size() * 2 + 1);
217  Type *Int64 = Type::getInt64Ty(Context);
218  Ops[0] = createString(Name);
219  for (unsigned i = 0, e = Fields.size(); i != e; ++i) {
220    Ops[i * 2 + 1] = Fields[i].first;
221    Ops[i * 2 + 2] = createConstant(ConstantInt::get(Int64, Fields[i].second));
222  }
223  return MDNode::get(Context, Ops);
224}
225
226/// Return metadata for a TBAA scalar type node with the
227/// given name, an offset and a parent in the TBAA type DAG.
228MDNode *MDBuilder::createTBAAScalarTypeNode(StringRef Name, MDNode *Parent,
229                                            uint64_t Offset) {
230  ConstantInt *Off = ConstantInt::get(Type::getInt64Ty(Context), Offset);
231  return MDNode::get(Context,
232                     {createString(Name), Parent, createConstant(Off)});
233}
234
235/// Return metadata for a TBAA tag node with the given
236/// base type, access type and offset relative to the base type.
237MDNode *MDBuilder::createTBAAStructTagNode(MDNode *BaseType, MDNode *AccessType,
238                                           uint64_t Offset, bool IsConstant) {
239  IntegerType *Int64 = Type::getInt64Ty(Context);
240  ConstantInt *Off = ConstantInt::get(Int64, Offset);
241  if (IsConstant) {
242    return MDNode::get(Context, {BaseType, AccessType, createConstant(Off),
243                                 createConstant(ConstantInt::get(Int64, 1))});
244  }
245  return MDNode::get(Context, {BaseType, AccessType, createConstant(Off)});
246}
247
248MDNode *MDBuilder::createTBAATypeNode(MDNode *Parent, uint64_t Size,
249                                      Metadata *Id,
250                                      ArrayRef<TBAAStructField> Fields) {
251  SmallVector<Metadata *, 4> Ops(3 + Fields.size() * 3);
252  Type *Int64 = Type::getInt64Ty(Context);
253  Ops[0] = Parent;
254  Ops[1] = createConstant(ConstantInt::get(Int64, Size));
255  Ops[2] = Id;
256  for (unsigned I = 0, E = Fields.size(); I != E; ++I) {
257    Ops[I * 3 + 3] = Fields[I].Type;
258    Ops[I * 3 + 4] = createConstant(ConstantInt::get(Int64, Fields[I].Offset));
259    Ops[I * 3 + 5] = createConstant(ConstantInt::get(Int64, Fields[I].Size));
260  }
261  return MDNode::get(Context, Ops);
262}
263
264MDNode *MDBuilder::createTBAAAccessTag(MDNode *BaseType, MDNode *AccessType,
265                                       uint64_t Offset, uint64_t Size,
266                                       bool IsImmutable) {
267  IntegerType *Int64 = Type::getInt64Ty(Context);
268  auto *OffsetNode = createConstant(ConstantInt::get(Int64, Offset));
269  auto *SizeNode = createConstant(ConstantInt::get(Int64, Size));
270  if (IsImmutable) {
271    auto *ImmutabilityFlagNode = createConstant(ConstantInt::get(Int64, 1));
272    return MDNode::get(Context, {BaseType, AccessType, OffsetNode, SizeNode,
273                                 ImmutabilityFlagNode});
274  }
275  return MDNode::get(Context, {BaseType, AccessType, OffsetNode, SizeNode});
276}
277
278MDNode *MDBuilder::createMutableTBAAAccessTag(MDNode *Tag) {
279  MDNode *BaseType = cast<MDNode>(Tag->getOperand(0));
280  MDNode *AccessType = cast<MDNode>(Tag->getOperand(1));
281  Metadata *OffsetNode = Tag->getOperand(2);
282  uint64_t Offset = mdconst::extract<ConstantInt>(OffsetNode)->getZExtValue();
283
284  bool NewFormat = isa<MDNode>(AccessType->getOperand(0));
285
286  // See if the tag is already mutable.
287  unsigned ImmutabilityFlagOp = NewFormat ? 4 : 3;
288  if (Tag->getNumOperands() <= ImmutabilityFlagOp)
289    return Tag;
290
291  // If Tag is already mutable then return it.
292  Metadata *ImmutabilityFlagNode = Tag->getOperand(ImmutabilityFlagOp);
293  if (!mdconst::extract<ConstantInt>(ImmutabilityFlagNode)->getValue())
294    return Tag;
295
296  // Otherwise, create another node.
297  if (!NewFormat)
298    return createTBAAStructTagNode(BaseType, AccessType, Offset);
299
300  Metadata *SizeNode = Tag->getOperand(3);
301  uint64_t Size = mdconst::extract<ConstantInt>(SizeNode)->getZExtValue();
302  return createTBAAAccessTag(BaseType, AccessType, Offset, Size);
303}
304
305MDNode *MDBuilder::createIrrLoopHeaderWeight(uint64_t Weight) {
306  Metadata *Vals[] = {
307    createString("loop_header_weight"),
308    createConstant(ConstantInt::get(Type::getInt64Ty(Context), Weight)),
309  };
310  return MDNode::get(Context, Vals);
311}
312
313MDNode *MDBuilder::createMisExpect(uint64_t Index, uint64_t LikleyWeight,
314                                   uint64_t UnlikleyWeight) {
315  auto *IntType = Type::getInt64Ty(Context);
316  Metadata *Vals[] = {
317      createString("misexpect"),
318      createConstant(ConstantInt::get(IntType, Index)),
319      createConstant(ConstantInt::get(IntType, LikleyWeight)),
320      createConstant(ConstantInt::get(IntType, UnlikleyWeight)),
321  };
322  return MDNode::get(Context, Vals);
323}
324