Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/lib/IR/MDBuilder.cpp
Line
Count
Source (jump to first uncovered line)
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
20
253k
MDString *MDBuilder::createString(StringRef Str) {
21
253k
  return MDString::get(Context, Str);
22
253k
}
23
24
702k
ConstantAsMetadata *MDBuilder::createConstant(Constant *C) {
25
702k
  return ConstantAsMetadata::get(C);
26
702k
}
27
28
17
MDNode *MDBuilder::createFPMath(float Accuracy) {
29
17
  if (Accuracy == 0.0)
30
1
    return nullptr;
31
16
  assert(Accuracy > 0.0 && "Invalid fpmath accuracy!");
32
16
  auto *Op =
33
16
      createConstant(ConstantFP::get(Type::getFloatTy(Context), Accuracy));
34
16
  return MDNode::get(Context, Op);
35
16
}
36
37
MDNode *MDBuilder::createBranchWeights(uint32_t TrueWeight,
38
29.5k
                                       uint32_t FalseWeight) {
39
29.5k
  return createBranchWeights({TrueWeight, FalseWeight});
40
29.5k
}
41
42
30.7k
MDNode *MDBuilder::createBranchWeights(ArrayRef<uint32_t> Weights) {
43
30.7k
  assert(Weights.size() >= 1 && "Need at least one branch weights!");
44
30.7k
45
30.7k
  SmallVector<Metadata *, 4> Vals(Weights.size() + 1);
46
30.7k
  Vals[0] = createString("branch_weights");
47
30.7k
48
30.7k
  Type *Int32Ty = Type::getInt32Ty(Context);
49
92.2k
  for (unsigned i = 0, e = Weights.size(); i != e; 
++i61.5k
)
50
61.5k
    Vals[i + 1] = createConstant(ConstantInt::get(Int32Ty, Weights[i]));
51
30.7k
52
30.7k
  return MDNode::get(Context, Vals);
53
30.7k
}
54
55
4
MDNode *MDBuilder::createUnpredictable() {
56
4
  return MDNode::get(Context, None);
57
4
}
58
59
MDNode *MDBuilder::createFunctionEntryCount(
60
    uint64_t Count, bool Synthetic,
61
661
    const DenseSet<GlobalValue::GUID> *Imports) {
62
661
  Type *Int64Ty = Type::getInt64Ty(Context);
63
661
  SmallVector<Metadata *, 8> Ops;
64
661
  if (Synthetic)
65
29
    Ops.push_back(createString("synthetic_function_entry_count"));
66
632
  else
67
632
    Ops.push_back(createString("function_entry_count"));
68
661
  Ops.push_back(createConstant(ConstantInt::get(Int64Ty, Count)));
69
661
  if (Imports) {
70
104
    SmallVector<GlobalValue::GUID, 2> OrderID(Imports->begin(), Imports->end());
71
104
    llvm::stable_sort(OrderID);
72
104
    for (auto ID : OrderID)
73
14
      Ops.push_back(createConstant(ConstantInt::get(Int64Ty, ID)));
74
104
  }
75
661
  return MDNode::get(Context, Ops);
76
661
}
77
78
32
MDNode *MDBuilder::createFunctionSectionPrefix(StringRef Prefix) {
79
32
  return MDNode::get(Context,
80
32
                     {createString("function_section_prefix"),
81
32
                      createString(Prefix)});
82
32
}
83
84
44.3k
MDNode *MDBuilder::createRange(const APInt &Lo, const APInt &Hi) {
85
44.3k
  assert(Lo.getBitWidth() == Hi.getBitWidth() && "Mismatched bitwidths!");
86
44.3k
87
44.3k
  Type *Ty = IntegerType::get(Context, Lo.getBitWidth());
88
44.3k
  return createRange(ConstantInt::get(Ty, Lo), ConstantInt::get(Ty, Hi));
89
44.3k
}
90
91
44.3k
MDNode *MDBuilder::createRange(Constant *Lo, Constant *Hi) {
92
44.3k
  // If the range is everything then it is useless.
93
44.3k
  if (Hi == Lo)
94
4
    return nullptr;
95
44.3k
96
44.3k
  // Return the range [Lo, Hi).
97
44.3k
  return MDNode::get(Context, {createConstant(Lo), createConstant(Hi)});
98
44.3k
}
99
100
100
MDNode *MDBuilder::createCallees(ArrayRef<Function *> Callees) {
101
100
  SmallVector<Metadata *, 4> Ops;
102
100
  for (Function *F : Callees)
103
210
    Ops.push_back(createConstant(F));
104
100
  return MDNode::get(Context, Ops);
105
100
}
106
107
MDNode *MDBuilder::createCallbackEncoding(unsigned CalleeArgNo,
108
                                          ArrayRef<int> Arguments,
109
1.79k
                                          bool VarArgArePassed) {
110
1.79k
  SmallVector<Metadata *, 4> Ops;
111
1.79k
112
1.79k
  Type *Int64 = Type::getInt64Ty(Context);
113
1.79k
  Ops.push_back(createConstant(ConstantInt::get(Int64, CalleeArgNo)));
114
1.79k
115
1.79k
  for (int ArgNo : Arguments)
116
3.56k
    Ops.push_back(createConstant(ConstantInt::get(Int64, ArgNo, true)));
117
1.79k
118
1.79k
  Type *Int1 = Type::getInt1Ty(Context);
119
1.79k
  Ops.push_back(createConstant(ConstantInt::get(Int1, VarArgArePassed)));
120
1.79k
121
1.79k
  return MDNode::get(Context, Ops);
122
1.79k
}
123
124
MDNode *MDBuilder::mergeCallbackEncodings(MDNode *ExistingCallbacks,
125
0
                                          MDNode *NewCB) {
126
0
  if (!ExistingCallbacks)
127
0
    return MDNode::get(Context, {NewCB});
128
0
129
0
  auto *NewCBCalleeIdxAsCM = cast<ConstantAsMetadata>(NewCB->getOperand(0));
130
0
  uint64_t NewCBCalleeIdx =
131
0
      cast<ConstantInt>(NewCBCalleeIdxAsCM->getValue())->getZExtValue();
132
0
  (void)NewCBCalleeIdx;
133
0
134
0
  SmallVector<Metadata *, 4> Ops;
135
0
  unsigned NumExistingOps = ExistingCallbacks->getNumOperands();
136
0
  Ops.resize(NumExistingOps + 1);
137
0
138
0
  for (unsigned u = 0; u < NumExistingOps; u++) {
139
0
    Ops[u] = ExistingCallbacks->getOperand(u);
140
0
141
0
    auto *OldCBCalleeIdxAsCM = cast<ConstantAsMetadata>(Ops[u]);
142
0
    uint64_t OldCBCalleeIdx =
143
0
      cast<ConstantInt>(OldCBCalleeIdxAsCM->getValue())->getZExtValue();
144
0
    (void)OldCBCalleeIdx;
145
0
    assert(NewCBCalleeIdx != OldCBCalleeIdx &&
146
0
           "Cannot map a callback callee index twice!");
147
0
  }
148
0
149
0
  Ops[NumExistingOps] = NewCB;
150
0
  return MDNode::get(Context, Ops);
151
0
}
152
153
20.4k
MDNode *MDBuilder::createAnonymousAARoot(StringRef Name, MDNode *Extra) {
154
20.4k
  // To ensure uniqueness the root node is self-referential.
155
20.4k
  auto Dummy = MDNode::getTemporary(Context, None);
156
20.4k
157
20.4k
  SmallVector<Metadata *, 3> Args(1, Dummy.get());
158
20.4k
  if (Extra)
159
12.5k
    Args.push_back(Extra);
160
20.4k
  if (!Name.empty())
161
14.6k
    Args.push_back(createString(Name));
162
20.4k
  MDNode *Root = MDNode::get(Context, Args);
163
20.4k
164
20.4k
  // At this point we have
165
20.4k
  //   !0 = metadata !{}            <- dummy
166
20.4k
  //   !1 = metadata !{metadata !0} <- root
167
20.4k
  // Replace the dummy operand with the root node itself and delete the dummy.
168
20.4k
  Root->replaceOperandWith(0, Root);
169
20.4k
170
20.4k
  // We now have
171
20.4k
  //   !1 = metadata !{metadata !1} <- self-referential root
172
20.4k
  return Root;
173
20.4k
}
174
175
7.18k
MDNode *MDBuilder::createTBAARoot(StringRef Name) {
176
7.18k
  return MDNode::get(Context, createString(Name));
177
7.18k
}
178
179
/// Return metadata for a non-root TBAA node with the given name,
180
/// parent in the TBAA tree, and value for 'pointsToConstantMemory'.
181
MDNode *MDBuilder::createTBAANode(StringRef Name, MDNode *Parent,
182
8
                                  bool isConstant) {
183
8
  if (isConstant) {
184
1
    Constant *Flags = ConstantInt::get(Type::getInt64Ty(Context), 1);
185
1
    return MDNode::get(Context,
186
1
                       {createString(Name), Parent, createConstant(Flags)});
187
1
  }
188
7
  return MDNode::get(Context, {createString(Name), Parent});
189
7
}
190
191
0
MDNode *MDBuilder::createAliasScopeDomain(StringRef Name) {
192
0
  return MDNode::get(Context, createString(Name));
193
0
}
194
195
0
MDNode *MDBuilder::createAliasScope(StringRef Name, MDNode *Domain) {
196
0
  return MDNode::get(Context, {createString(Name), Domain});
197
0
}
198
199
/// Return metadata for a tbaa.struct node with the given
200
/// struct field descriptions.
201
11.6k
MDNode *MDBuilder::createTBAAStructNode(ArrayRef<TBAAStructField> Fields) {
202
11.6k
  SmallVector<Metadata *, 4> Vals(Fields.size() * 3);
203
11.6k
  Type *Int64 = Type::getInt64Ty(Context);
204
40.1k
  for (unsigned i = 0, e = Fields.size(); i != e; 
++i28.5k
) {
205
28.5k
    Vals[i * 3 + 0] = createConstant(ConstantInt::get(Int64, Fields[i].Offset));
206
28.5k
    Vals[i * 3 + 1] = createConstant(ConstantInt::get(Int64, Fields[i].Size));
207
28.5k
    Vals[i * 3 + 2] = Fields[i].Type;
208
28.5k
  }
209
11.6k
  return MDNode::get(Context, Vals);
210
11.6k
}
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).
214
MDNode *MDBuilder::createTBAAStructTypeNode(
215
52.8k
    StringRef Name, ArrayRef<std::pair<MDNode *, uint64_t>> Fields) {
216
52.8k
  SmallVector<Metadata *, 4> Ops(Fields.size() * 2 + 1);
217
52.8k
  Type *Int64 = Type::getInt64Ty(Context);
218
52.8k
  Ops[0] = createString(Name);
219
293k
  for (unsigned i = 0, e = Fields.size(); i != e; 
++i240k
) {
220
240k
    Ops[i * 2 + 1] = Fields[i].first;
221
240k
    Ops[i * 2 + 2] = createConstant(ConstantInt::get(Int64, Fields[i].second));
222
240k
  }
223
52.8k
  return MDNode::get(Context, Ops);
224
52.8k
}
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.
228
MDNode *MDBuilder::createTBAAScalarTypeNode(StringRef Name, MDNode *Parent,
229
146k
                                            uint64_t Offset) {
230
146k
  ConstantInt *Off = ConstantInt::get(Type::getInt64Ty(Context), Offset);
231
146k
  return MDNode::get(Context,
232
146k
                     {createString(Name), Parent, createConstant(Off)});
233
146k
}
234
235
/// Return metadata for a TBAA tag node with the given
236
/// base type, access type and offset relative to the base type.
237
MDNode *MDBuilder::createTBAAStructTagNode(MDNode *BaseType, MDNode *AccessType,
238
98.3k
                                           uint64_t Offset, bool IsConstant) {
239
98.3k
  IntegerType *Int64 = Type::getInt64Ty(Context);
240
98.3k
  ConstantInt *Off = ConstantInt::get(Int64, Offset);
241
98.3k
  if (IsConstant) {
242
0
    return MDNode::get(Context, {BaseType, AccessType, createConstant(Off),
243
0
                                 createConstant(ConstantInt::get(Int64, 1))});
244
0
  }
245
98.3k
  return MDNode::get(Context, {BaseType, AccessType, createConstant(Off)});
246
98.3k
}
247
248
MDNode *MDBuilder::createTBAATypeNode(MDNode *Parent, uint64_t Size,
249
                                      Metadata *Id,
250
104
                                      ArrayRef<TBAAStructField> Fields) {
251
104
  SmallVector<Metadata *, 4> Ops(3 + Fields.size() * 3);
252
104
  Type *Int64 = Type::getInt64Ty(Context);
253
104
  Ops[0] = Parent;
254
104
  Ops[1] = createConstant(ConstantInt::get(Int64, Size));
255
104
  Ops[2] = Id;
256
177
  for (unsigned I = 0, E = Fields.size(); I != E; 
++I73
) {
257
73
    Ops[I * 3 + 3] = Fields[I].Type;
258
73
    Ops[I * 3 + 4] = createConstant(ConstantInt::get(Int64, Fields[I].Offset));
259
73
    Ops[I * 3 + 5] = createConstant(ConstantInt::get(Int64, Fields[I].Size));
260
73
  }
261
104
  return MDNode::get(Context, Ops);
262
104
}
263
264
MDNode *MDBuilder::createTBAAAccessTag(MDNode *BaseType, MDNode *AccessType,
265
                                       uint64_t Offset, uint64_t Size,
266
68
                                       bool IsImmutable) {
267
68
  IntegerType *Int64 = Type::getInt64Ty(Context);
268
68
  auto *OffsetNode = createConstant(ConstantInt::get(Int64, Offset));
269
68
  auto *SizeNode = createConstant(ConstantInt::get(Int64, Size));
270
68
  if (IsImmutable) {
271
0
    auto *ImmutabilityFlagNode = createConstant(ConstantInt::get(Int64, 1));
272
0
    return MDNode::get(Context, {BaseType, AccessType, OffsetNode, SizeNode,
273
0
                                 ImmutabilityFlagNode});
274
0
  }
275
68
  return MDNode::get(Context, {BaseType, AccessType, OffsetNode, SizeNode});
276
68
}
277
278
4
MDNode *MDBuilder::createMutableTBAAAccessTag(MDNode *Tag) {
279
4
  MDNode *BaseType = cast<MDNode>(Tag->getOperand(0));
280
4
  MDNode *AccessType = cast<MDNode>(Tag->getOperand(1));
281
4
  Metadata *OffsetNode = Tag->getOperand(2);
282
4
  uint64_t Offset = mdconst::extract<ConstantInt>(OffsetNode)->getZExtValue();
283
4
284
4
  bool NewFormat = isa<MDNode>(AccessType->getOperand(0));
285
4
286
4
  // See if the tag is already mutable.
287
4
  unsigned ImmutabilityFlagOp = NewFormat ? 
42
:
32
;
288
4
  if (Tag->getNumOperands() <= ImmutabilityFlagOp)
289
0
    return Tag;
290
4
291
4
  // If Tag is already mutable then return it.
292
4
  Metadata *ImmutabilityFlagNode = Tag->getOperand(ImmutabilityFlagOp);
293
4
  if (!mdconst::extract<ConstantInt>(ImmutabilityFlagNode)->getValue())
294
0
    return Tag;
295
4
296
4
  // Otherwise, create another node.
297
4
  if (!NewFormat)
298
2
    return createTBAAStructTagNode(BaseType, AccessType, Offset);
299
2
300
2
  Metadata *SizeNode = Tag->getOperand(3);
301
2
  uint64_t Size = mdconst::extract<ConstantInt>(SizeNode)->getZExtValue();
302
2
  return createTBAAAccessTag(BaseType, AccessType, Offset, Size);
303
2
}
304
305
29
MDNode *MDBuilder::createIrrLoopHeaderWeight(uint64_t Weight) {
306
29
  Metadata *Vals[] = {
307
29
    createString("loop_header_weight"),
308
29
    createConstant(ConstantInt::get(Type::getInt64Ty(Context), Weight)),
309
29
  };
310
29
  return MDNode::get(Context, Vals);
311
29
}