?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PowerPC] Do not use vectors to codegen bswap with Altivec turned off
[llvm-core.git] / unittests / IR / MetadataTest.cpp
blobb2ffb80b15ee7f8dc050ee89893fed7b1aa7d16a
1 //===- unittests/IR/MetadataTest.cpp - Metadata unit tests ----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "llvm/IR/Metadata.h"
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/IR/Constants.h"
13 #include "llvm/IR/DebugInfo.h"
14 #include "llvm/IR/DebugInfoMetadata.h"
15 #include "llvm/IR/Function.h"
16 #include "llvm/IR/Instructions.h"
17 #include "llvm/IR/LLVMContext.h"
18 #include "llvm/IR/Module.h"
19 #include "llvm/IR/ModuleSlotTracker.h"
20 #include "llvm/IR/Type.h"
21 #include "llvm/IR/Verifier.h"
22 #include "llvm/Support/raw_ostream.h"
23 #include "gtest/gtest.h"
24 using namespace llvm;
25
26 namespace {
27
28 TEST(ContextAndReplaceableUsesTest, FromContext) {
29 LLVMContext Context;
30 ContextAndReplaceableUses CRU(Context);
31 EXPECT_EQ(&Context, &CRU.getContext());
32 EXPECT_FALSE(CRU.hasReplaceableUses());
33 EXPECT_FALSE(CRU.getReplaceableUses());
34 }
35
36 TEST(ContextAndReplaceableUsesTest, FromReplaceableUses) {
37 LLVMContext Context;
38 ContextAndReplaceableUses CRU(make_unique<ReplaceableMetadataImpl>(Context));
39 EXPECT_EQ(&Context, &CRU.getContext());
40 EXPECT_TRUE(CRU.hasReplaceableUses());
41 EXPECT_TRUE(CRU.getReplaceableUses());
42 }
43
44 TEST(ContextAndReplaceableUsesTest, makeReplaceable) {
45 LLVMContext Context;
46 ContextAndReplaceableUses CRU(Context);
47 CRU.makeReplaceable(make_unique<ReplaceableMetadataImpl>(Context));
48 EXPECT_EQ(&Context, &CRU.getContext());
49 EXPECT_TRUE(CRU.hasReplaceableUses());
50 EXPECT_TRUE(CRU.getReplaceableUses());
51 }
52
53 TEST(ContextAndReplaceableUsesTest, takeReplaceableUses) {
54 LLVMContext Context;
55 auto ReplaceableUses = make_unique<ReplaceableMetadataImpl>(Context);
56 auto *Ptr = ReplaceableUses.get();
57 ContextAndReplaceableUses CRU(std::move(ReplaceableUses));
58 ReplaceableUses = CRU.takeReplaceableUses();
59 EXPECT_EQ(&Context, &CRU.getContext());
60 EXPECT_FALSE(CRU.hasReplaceableUses());
61 EXPECT_FALSE(CRU.getReplaceableUses());
62 EXPECT_EQ(Ptr, ReplaceableUses.get());
63 }
64
65 class MetadataTest : public testing::Test {
66 public:
67 MetadataTest() : M("test", Context), Counter(0) {}
68
69 protected:
70 LLVMContext Context;
71 Module M;
72 int Counter;
73
74 MDNode *getNode() { return MDNode::get(Context, None); }
75 MDNode *getNode(Metadata *MD) { return MDNode::get(Context, MD); }
76 MDNode *getNode(Metadata *MD1, Metadata *MD2) {
77 Metadata *MDs[] = {MD1, MD2};
78 return MDNode::get(Context, MDs);
79 }
80
81 MDTuple *getTuple() { return MDTuple::getDistinct(Context, None); }
82 DISubroutineType *getSubroutineType() {
83 return DISubroutineType::getDistinct(Context, DINode::FlagZero, 0,
84 getNode(nullptr));
85 }
86 DISubprogram *getSubprogram() {
87 return DISubprogram::getDistinct(
88 Context, nullptr, "", "", nullptr, 0, nullptr, 0, nullptr, 0, 0,
89 DINode::FlagZero, DISubprogram::SPFlagZero, nullptr);
90 }
91 DIFile *getFile() {
92 return DIFile::getDistinct(Context, "file.c", "/path/to/dir");
93 }
94 DICompileUnit *getUnit() {
95 return DICompileUnit::getDistinct(
96 Context, 1, getFile(), "clang", false, "-g", 2, "",
97 DICompileUnit::FullDebug, getTuple(), getTuple(), getTuple(),
98 getTuple(), getTuple(), 0, true, false,
99 DICompileUnit::DebugNameTableKind::Default, false);
100 }
101 DIType *getBasicType(StringRef Name) {
102 return DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type, Name);
103 }
104 DIType *getDerivedType() {
105 return DIDerivedType::getDistinct(
106 Context, dwarf::DW_TAG_pointer_type, "", nullptr, 0, nullptr,
107 getBasicType("basictype"), 1, 2, 0, None, DINode::FlagZero);
108 }
109 Constant *getConstant() {
110 return ConstantInt::get(Type::getInt32Ty(Context), Counter++);
111 }
112 ConstantAsMetadata *getConstantAsMetadata() {
113 return ConstantAsMetadata::get(getConstant());
114 }
115 DIType *getCompositeType() {
116 return DICompositeType::getDistinct(
117 Context, dwarf::DW_TAG_structure_type, "", nullptr, 0, nullptr, nullptr,
118 32, 32, 0, DINode::FlagZero, nullptr, 0, nullptr, nullptr, "");
119 }
120 Function *getFunction(StringRef Name) {
121 return cast<Function>(M.getOrInsertFunction(
122 Name, FunctionType::get(Type::getVoidTy(Context), None, false)));
123 }
124 };
125 typedef MetadataTest MDStringTest;
126
127 // Test that construction of MDString with different value produces different
128 // MDString objects, even with the same string pointer and nulls in the string.
129 TEST_F(MDStringTest, CreateDifferent) {
130 char x[3] = { 'f', 0, 'A' };
131 MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
132 x[2] = 'B';
133 MDString *s2 = MDString::get(Context, StringRef(&x[0], 3));
134 EXPECT_NE(s1, s2);
135 }
136
137 // Test that creation of MDStrings with the same string contents produces the
138 // same MDString object, even with different pointers.
139 TEST_F(MDStringTest, CreateSame) {
140 char x[4] = { 'a', 'b', 'c', 'X' };
141 char y[4] = { 'a', 'b', 'c', 'Y' };
142
143 MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
144 MDString *s2 = MDString::get(Context, StringRef(&y[0], 3));
145 EXPECT_EQ(s1, s2);
146 }
147
148 // Test that MDString prints out the string we fed it.
149 TEST_F(MDStringTest, PrintingSimple) {
150 char *str = new char[13];
151 strncpy(str, "testing 1 2 3", 13);
152 MDString *s = MDString::get(Context, StringRef(str, 13));
153 strncpy(str, "aaaaaaaaaaaaa", 13);
154 delete[] str;
155
156 std::string Str;
157 raw_string_ostream oss(Str);
158 s->print(oss);
159 EXPECT_STREQ("!\"testing 1 2 3\"", oss.str().c_str());
160 }
161
162 // Test printing of MDString with non-printable characters.
163 TEST_F(MDStringTest, PrintingComplex) {
164 char str[5] = {0, '\n', '"', '\\', (char)-1};
165 MDString *s = MDString::get(Context, StringRef(str+0, 5));
166 std::string Str;
167 raw_string_ostream oss(Str);
168 s->print(oss);
169 EXPECT_STREQ("!\"\\00\\0A\\22\\5C\\FF\"", oss.str().c_str());
170 }
171
172 typedef MetadataTest MDNodeTest;
173
174 // Test the two constructors, and containing other Constants.
175 TEST_F(MDNodeTest, Simple) {
176 char x[3] = { 'a', 'b', 'c' };
177 char y[3] = { '1', '2', '3' };
178
179 MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
180 MDString *s2 = MDString::get(Context, StringRef(&y[0], 3));
181 ConstantAsMetadata *CI =
182 ConstantAsMetadata::get(ConstantInt::get(Context, APInt(8, 0)));
183
184 std::vector<Metadata *> V;
185 V.push_back(s1);
186 V.push_back(CI);
187 V.push_back(s2);
188
189 MDNode *n1 = MDNode::get(Context, V);
190 Metadata *const c1 = n1;
191 MDNode *n2 = MDNode::get(Context, c1);
192 Metadata *const c2 = n2;
193 MDNode *n3 = MDNode::get(Context, V);
194 MDNode *n4 = MDNode::getIfExists(Context, V);
195 MDNode *n5 = MDNode::getIfExists(Context, c1);
196 MDNode *n6 = MDNode::getIfExists(Context, c2);
197 EXPECT_NE(n1, n2);
198 EXPECT_EQ(n1, n3);
199 EXPECT_EQ(n4, n1);
200 EXPECT_EQ(n5, n2);
201 EXPECT_EQ(n6, (Metadata *)nullptr);
202
203 EXPECT_EQ(3u, n1->getNumOperands());
204 EXPECT_EQ(s1, n1->getOperand(0));
205 EXPECT_EQ(CI, n1->getOperand(1));
206 EXPECT_EQ(s2, n1->getOperand(2));
207
208 EXPECT_EQ(1u, n2->getNumOperands());
209 EXPECT_EQ(n1, n2->getOperand(0));
210 }
211
212 TEST_F(MDNodeTest, Delete) {
213 Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 1);
214 Instruction *I = new BitCastInst(C, Type::getInt32Ty(Context));
215
216 Metadata *const V = LocalAsMetadata::get(I);
217 MDNode *n = MDNode::get(Context, V);
218 TrackingMDRef wvh(n);
219
220 EXPECT_EQ(n, wvh);
221
222 I->deleteValue();
223 }
224
225 TEST_F(MDNodeTest, SelfReference) {
226 // !0 = !{!0}
227 // !1 = !{!0}
228 {
229 auto Temp = MDNode::getTemporary(Context, None);
230 Metadata *Args[] = {Temp.get()};
231 MDNode *Self = MDNode::get(Context, Args);
232 Self->replaceOperandWith(0, Self);
233 ASSERT_EQ(Self, Self->getOperand(0));
234
235 // Self-references should be distinct, so MDNode::get() should grab a
236 // uniqued node that references Self, not Self.
237 Args[0] = Self;
238 MDNode *Ref1 = MDNode::get(Context, Args);
239 MDNode *Ref2 = MDNode::get(Context, Args);
240 EXPECT_NE(Self, Ref1);
241 EXPECT_EQ(Ref1, Ref2);
242 }
243
244 // !0 = !{!0, !{}}
245 // !1 = !{!0, !{}}
246 {
247 auto Temp = MDNode::getTemporary(Context, None);
248 Metadata *Args[] = {Temp.get(), MDNode::get(Context, None)};
249 MDNode *Self = MDNode::get(Context, Args);
250 Self->replaceOperandWith(0, Self);
251 ASSERT_EQ(Self, Self->getOperand(0));
252
253 // Self-references should be distinct, so MDNode::get() should grab a
254 // uniqued node that references Self, not Self itself.
255 Args[0] = Self;
256 MDNode *Ref1 = MDNode::get(Context, Args);
257 MDNode *Ref2 = MDNode::get(Context, Args);
258 EXPECT_NE(Self, Ref1);
259 EXPECT_EQ(Ref1, Ref2);
260 }
261 }
262
263 TEST_F(MDNodeTest, Print) {
264 Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 7);
265 MDString *S = MDString::get(Context, "foo");
266 MDNode *N0 = getNode();
267 MDNode *N1 = getNode(N0);
268 MDNode *N2 = getNode(N0, N1);
269
270 Metadata *Args[] = {ConstantAsMetadata::get(C), S, nullptr, N0, N1, N2};
271 MDNode *N = MDNode::get(Context, Args);
272
273 std::string Expected;
274 {
275 raw_string_ostream OS(Expected);
276 OS << "<" << (void *)N << "> = !{";
277 C->printAsOperand(OS);
278 OS << ", ";
279 S->printAsOperand(OS);
280 OS << ", null";
281 MDNode *Nodes[] = {N0, N1, N2};
282 for (auto *Node : Nodes)
283 OS << ", <" << (void *)Node << ">";
284 OS << "}";
285 }
286
287 std::string Actual;
288 {
289 raw_string_ostream OS(Actual);
290 N->print(OS);
291 }
292
293 EXPECT_EQ(Expected, Actual);
294 }
295
296 #define EXPECT_PRINTER_EQ(EXPECTED, PRINT) \
297 do { \
298 std::string Actual_; \
299 raw_string_ostream OS(Actual_); \
300 PRINT; \
301 OS.flush(); \
302 std::string Expected_(EXPECTED); \
303 EXPECT_EQ(Expected_, Actual_); \
304 } while (false)
305
306 TEST_F(MDNodeTest, PrintTemporary) {
307 MDNode *Arg = getNode();
308 TempMDNode Temp = MDNode::getTemporary(Context, Arg);
309 MDNode *N = getNode(Temp.get());
310 Module M("test", Context);
311 NamedMDNode *NMD = M.getOrInsertNamedMetadata("named");
312 NMD->addOperand(N);
313
314 EXPECT_PRINTER_EQ("!0 = !{!1}", N->print(OS, &M));
315 EXPECT_PRINTER_EQ("!1 = <temporary!> !{!2}", Temp->print(OS, &M));
316 EXPECT_PRINTER_EQ("!2 = !{}", Arg->print(OS, &M));
317
318 // Cleanup.
319 Temp->replaceAllUsesWith(Arg);
320 }
321
322 TEST_F(MDNodeTest, PrintFromModule) {
323 Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 7);
324 MDString *S = MDString::get(Context, "foo");
325 MDNode *N0 = getNode();
326 MDNode *N1 = getNode(N0);
327 MDNode *N2 = getNode(N0, N1);
328
329 Metadata *Args[] = {ConstantAsMetadata::get(C), S, nullptr, N0, N1, N2};
330 MDNode *N = MDNode::get(Context, Args);
331 Module M("test", Context);
332 NamedMDNode *NMD = M.getOrInsertNamedMetadata("named");
333 NMD->addOperand(N);
334
335 std::string Expected;
336 {
337 raw_string_ostream OS(Expected);
338 OS << "!0 = !{";
339 C->printAsOperand(OS);
340 OS << ", ";
341 S->printAsOperand(OS);
342 OS << ", null, !1, !2, !3}";
343 }
344
345 EXPECT_PRINTER_EQ(Expected, N->print(OS, &M));
346 }
347
348 TEST_F(MDNodeTest, PrintFromFunction) {
349 Module M("test", Context);
350 auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
351 auto *F0 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F0", &M);
352 auto *F1 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F1", &M);
353 auto *BB0 = BasicBlock::Create(Context, "entry", F0);
354 auto *BB1 = BasicBlock::Create(Context, "entry", F1);
355 auto *R0 = ReturnInst::Create(Context, BB0);
356 auto *R1 = ReturnInst::Create(Context, BB1);
357 auto *N0 = MDNode::getDistinct(Context, None);
358 auto *N1 = MDNode::getDistinct(Context, None);
359 R0->setMetadata("md", N0);
360 R1->setMetadata("md", N1);
361
362 EXPECT_PRINTER_EQ("!0 = distinct !{}", N0->print(OS, &M));
363 EXPECT_PRINTER_EQ("!1 = distinct !{}", N1->print(OS, &M));
364
365 ModuleSlotTracker MST(&M);
366 EXPECT_PRINTER_EQ("!0 = distinct !{}", N0->print(OS, MST));
367 EXPECT_PRINTER_EQ("!1 = distinct !{}", N1->print(OS, MST));
368 }
369
370 TEST_F(MDNodeTest, PrintFromMetadataAsValue) {
371 Module M("test", Context);
372
373 auto *Intrinsic =
374 Function::Create(FunctionType::get(Type::getVoidTy(Context),
375 Type::getMetadataTy(Context), false),
376 GlobalValue::ExternalLinkage, "llvm.intrinsic", &M);
377
378 auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
379 auto *F0 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F0", &M);
380 auto *F1 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F1", &M);
381 auto *BB0 = BasicBlock::Create(Context, "entry", F0);
382 auto *BB1 = BasicBlock::Create(Context, "entry", F1);
383 auto *N0 = MDNode::getDistinct(Context, None);
384 auto *N1 = MDNode::getDistinct(Context, None);
385 auto *MAV0 = MetadataAsValue::get(Context, N0);
386 auto *MAV1 = MetadataAsValue::get(Context, N1);
387 CallInst::Create(Intrinsic, MAV0, "", BB0);
388 CallInst::Create(Intrinsic, MAV1, "", BB1);
389
390 EXPECT_PRINTER_EQ("!0 = distinct !{}", MAV0->print(OS));
391 EXPECT_PRINTER_EQ("!1 = distinct !{}", MAV1->print(OS));
392 EXPECT_PRINTER_EQ("!0", MAV0->printAsOperand(OS, false));
393 EXPECT_PRINTER_EQ("!1", MAV1->printAsOperand(OS, false));
394 EXPECT_PRINTER_EQ("metadata !0", MAV0->printAsOperand(OS, true));
395 EXPECT_PRINTER_EQ("metadata !1", MAV1->printAsOperand(OS, true));
396
397 ModuleSlotTracker MST(&M);
398 EXPECT_PRINTER_EQ("!0 = distinct !{}", MAV0->print(OS, MST));
399 EXPECT_PRINTER_EQ("!1 = distinct !{}", MAV1->print(OS, MST));
400 EXPECT_PRINTER_EQ("!0", MAV0->printAsOperand(OS, false, MST));
401 EXPECT_PRINTER_EQ("!1", MAV1->printAsOperand(OS, false, MST));
402 EXPECT_PRINTER_EQ("metadata !0", MAV0->printAsOperand(OS, true, MST));
403 EXPECT_PRINTER_EQ("metadata !1", MAV1->printAsOperand(OS, true, MST));
404 }
405
406 TEST_F(MDNodeTest, PrintWithDroppedCallOperand) {
407 Module M("test", Context);
408
409 auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
410 auto *F0 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F0", &M);
411 auto *F1 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F1", &M);
412 auto *BB0 = BasicBlock::Create(Context, "entry", F0);
413
414 CallInst *CI0 = CallInst::Create(F1, "", BB0);
415 CI0->dropAllReferences();
416
417 auto *R0 = ReturnInst::Create(Context, BB0);
418 auto *N0 = MDNode::getDistinct(Context, None);
419 R0->setMetadata("md", N0);
420
421 // Printing the metadata node would previously result in a failed assertion
422 // due to the call instruction's dropped function operand.
423 ModuleSlotTracker MST(&M);
424 EXPECT_PRINTER_EQ("!0 = distinct !{}", N0->print(OS, MST));
425 }
426 #undef EXPECT_PRINTER_EQ
427
428 TEST_F(MDNodeTest, NullOperand) {
429 // metadata !{}
430 MDNode *Empty = MDNode::get(Context, None);
431
432 // metadata !{metadata !{}}
433 Metadata *Ops[] = {Empty};
434 MDNode *N = MDNode::get(Context, Ops);
435 ASSERT_EQ(Empty, N->getOperand(0));
436
437 // metadata !{metadata !{}} => metadata !{null}
438 N->replaceOperandWith(0, nullptr);
439 ASSERT_EQ(nullptr, N->getOperand(0));
440
441 // metadata !{null}
442 Ops[0] = nullptr;
443 MDNode *NullOp = MDNode::get(Context, Ops);
444 ASSERT_EQ(nullptr, NullOp->getOperand(0));
445 EXPECT_EQ(N, NullOp);
446 }
447
448 TEST_F(MDNodeTest, DistinctOnUniquingCollision) {
449 // !{}
450 MDNode *Empty = MDNode::get(Context, None);
451 ASSERT_TRUE(Empty->isResolved());
452 EXPECT_FALSE(Empty->isDistinct());
453
454 // !{!{}}
455 Metadata *Wrapped1Ops[] = {Empty};
456 MDNode *Wrapped1 = MDNode::get(Context, Wrapped1Ops);
457 ASSERT_EQ(Empty, Wrapped1->getOperand(0));
458 ASSERT_TRUE(Wrapped1->isResolved());
459 EXPECT_FALSE(Wrapped1->isDistinct());
460
461 // !{!{!{}}}
462 Metadata *Wrapped2Ops[] = {Wrapped1};
463 MDNode *Wrapped2 = MDNode::get(Context, Wrapped2Ops);
464 ASSERT_EQ(Wrapped1, Wrapped2->getOperand(0));
465 ASSERT_TRUE(Wrapped2->isResolved());
466 EXPECT_FALSE(Wrapped2->isDistinct());
467
468 // !{!{!{}}} => !{!{}}
469 Wrapped2->replaceOperandWith(0, Empty);
470 ASSERT_EQ(Empty, Wrapped2->getOperand(0));
471 EXPECT_TRUE(Wrapped2->isDistinct());
472 EXPECT_FALSE(Wrapped1->isDistinct());
473 }
474
475 TEST_F(MDNodeTest, UniquedOnDeletedOperand) {
476 // temp !{}
477 TempMDTuple T = MDTuple::getTemporary(Context, None);
478
479 // !{temp !{}}
480 Metadata *Ops[] = {T.get()};
481 MDTuple *N = MDTuple::get(Context, Ops);
482
483 // !{temp !{}} => !{null}
484 T.reset();
485 ASSERT_TRUE(N->isUniqued());
486 Metadata *NullOps[] = {nullptr};
487 ASSERT_EQ(N, MDTuple::get(Context, NullOps));
488 }
489
490 TEST_F(MDNodeTest, DistinctOnDeletedValueOperand) {
491 // i1* @GV
492 Type *Ty = Type::getInt1PtrTy(Context);
493 std::unique_ptr<GlobalVariable> GV(
494 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
495 ConstantAsMetadata *Op = ConstantAsMetadata::get(GV.get());
496
497 // !{i1* @GV}
498 Metadata *Ops[] = {Op};
499 MDTuple *N = MDTuple::get(Context, Ops);
500
501 // !{i1* @GV} => !{null}
502 GV.reset();
503 ASSERT_TRUE(N->isDistinct());
504 ASSERT_EQ(nullptr, N->getOperand(0));
505 Metadata *NullOps[] = {nullptr};
506 ASSERT_NE(N, MDTuple::get(Context, NullOps));
507 }
508
509 TEST_F(MDNodeTest, getDistinct) {
510 // !{}
511 MDNode *Empty = MDNode::get(Context, None);
512 ASSERT_TRUE(Empty->isResolved());
513 ASSERT_FALSE(Empty->isDistinct());
514 ASSERT_EQ(Empty, MDNode::get(Context, None));
515
516 // distinct !{}
517 MDNode *Distinct1 = MDNode::getDistinct(Context, None);
518 MDNode *Distinct2 = MDNode::getDistinct(Context, None);
519 EXPECT_TRUE(Distinct1->isResolved());
520 EXPECT_TRUE(Distinct2->isDistinct());
521 EXPECT_NE(Empty, Distinct1);
522 EXPECT_NE(Empty, Distinct2);
523 EXPECT_NE(Distinct1, Distinct2);
524
525 // !{}
526 ASSERT_EQ(Empty, MDNode::get(Context, None));
527 }
528
529 TEST_F(MDNodeTest, isUniqued) {
530 MDNode *U = MDTuple::get(Context, None);
531 MDNode *D = MDTuple::getDistinct(Context, None);
532 auto T = MDTuple::getTemporary(Context, None);
533 EXPECT_TRUE(U->isUniqued());
534 EXPECT_FALSE(D->isUniqued());
535 EXPECT_FALSE(T->isUniqued());
536 }
537
538 TEST_F(MDNodeTest, isDistinct) {
539 MDNode *U = MDTuple::get(Context, None);
540 MDNode *D = MDTuple::getDistinct(Context, None);
541 auto T = MDTuple::getTemporary(Context, None);
542 EXPECT_FALSE(U->isDistinct());
543 EXPECT_TRUE(D->isDistinct());
544 EXPECT_FALSE(T->isDistinct());
545 }
546
547 TEST_F(MDNodeTest, isTemporary) {
548 MDNode *U = MDTuple::get(Context, None);
549 MDNode *D = MDTuple::getDistinct(Context, None);
550 auto T = MDTuple::getTemporary(Context, None);
551 EXPECT_FALSE(U->isTemporary());
552 EXPECT_FALSE(D->isTemporary());
553 EXPECT_TRUE(T->isTemporary());
554 }
555
556 TEST_F(MDNodeTest, getDistinctWithUnresolvedOperands) {
557 // temporary !{}
558 auto Temp = MDTuple::getTemporary(Context, None);
559 ASSERT_FALSE(Temp->isResolved());
560
561 // distinct !{temporary !{}}
562 Metadata *Ops[] = {Temp.get()};
563 MDNode *Distinct = MDNode::getDistinct(Context, Ops);
564 EXPECT_TRUE(Distinct->isResolved());
565 EXPECT_EQ(Temp.get(), Distinct->getOperand(0));
566
567 // temporary !{} => !{}
568 MDNode *Empty = MDNode::get(Context, None);
569 Temp->replaceAllUsesWith(Empty);
570 EXPECT_EQ(Empty, Distinct->getOperand(0));
571 }
572
573 TEST_F(MDNodeTest, handleChangedOperandRecursion) {
574 // !0 = !{}
575 MDNode *N0 = MDNode::get(Context, None);
576
577 // !1 = !{!3, null}
578 auto Temp3 = MDTuple::getTemporary(Context, None);
579 Metadata *Ops1[] = {Temp3.get(), nullptr};
580 MDNode *N1 = MDNode::get(Context, Ops1);
581
582 // !2 = !{!3, !0}
583 Metadata *Ops2[] = {Temp3.get(), N0};
584 MDNode *N2 = MDNode::get(Context, Ops2);
585
586 // !3 = !{!2}
587 Metadata *Ops3[] = {N2};
588 MDNode *N3 = MDNode::get(Context, Ops3);
589 Temp3->replaceAllUsesWith(N3);
590
591 // !4 = !{!1}
592 Metadata *Ops4[] = {N1};
593 MDNode *N4 = MDNode::get(Context, Ops4);
594
595 // Confirm that the cycle prevented RAUW from getting dropped.
596 EXPECT_TRUE(N0->isResolved());
597 EXPECT_FALSE(N1->isResolved());
598 EXPECT_FALSE(N2->isResolved());
599 EXPECT_FALSE(N3->isResolved());
600 EXPECT_FALSE(N4->isResolved());
601
602 // Create a couple of distinct nodes to observe what's going on.
603 //
604 // !5 = distinct !{!2}
605 // !6 = distinct !{!3}
606 Metadata *Ops5[] = {N2};
607 MDNode *N5 = MDNode::getDistinct(Context, Ops5);
608 Metadata *Ops6[] = {N3};
609 MDNode *N6 = MDNode::getDistinct(Context, Ops6);
610
611 // Mutate !2 to look like !1, causing a uniquing collision (and an RAUW).
612 // This will ripple up, with !3 colliding with !4, and RAUWing. Since !2
613 // references !3, this can cause a re-entry of handleChangedOperand() when !3
614 // is not ready for it.
615 //
616 // !2->replaceOperandWith(1, nullptr)
617 // !2: !{!3, !0} => !{!3, null}
618 // !2->replaceAllUsesWith(!1)
619 // !3: !{!2] => !{!1}
620 // !3->replaceAllUsesWith(!4)
621 N2->replaceOperandWith(1, nullptr);
622
623 // If all has gone well, N2 and N3 will have been RAUW'ed and deleted from
624 // under us. Just check that the other nodes are sane.
625 //
626 // !1 = !{!4, null}
627 // !4 = !{!1}
628 // !5 = distinct !{!1}
629 // !6 = distinct !{!4}
630 EXPECT_EQ(N4, N1->getOperand(0));
631 EXPECT_EQ(N1, N4->getOperand(0));
632 EXPECT_EQ(N1, N5->getOperand(0));
633 EXPECT_EQ(N4, N6->getOperand(0));
634 }
635
636 TEST_F(MDNodeTest, replaceResolvedOperand) {
637 // Check code for replacing one resolved operand with another. If doing this
638 // directly (via replaceOperandWith()) becomes illegal, change the operand to
639 // a global value that gets RAUW'ed.
640 //
641 // Use a temporary node to keep N from being resolved.
642 auto Temp = MDTuple::getTemporary(Context, None);
643 Metadata *Ops[] = {nullptr, Temp.get()};
644
645 MDNode *Empty = MDTuple::get(Context, ArrayRef<Metadata *>());
646 MDNode *N = MDTuple::get(Context, Ops);
647 EXPECT_EQ(nullptr, N->getOperand(0));
648 ASSERT_FALSE(N->isResolved());
649
650 // Check code for replacing resolved nodes.
651 N->replaceOperandWith(0, Empty);
652 EXPECT_EQ(Empty, N->getOperand(0));
653
654 // Check code for adding another unresolved operand.
655 N->replaceOperandWith(0, Temp.get());
656 EXPECT_EQ(Temp.get(), N->getOperand(0));
657
658 // Remove the references to Temp; required for teardown.
659 Temp->replaceAllUsesWith(nullptr);
660 }
661
662 TEST_F(MDNodeTest, replaceWithUniqued) {
663 auto *Empty = MDTuple::get(Context, None);
664 MDTuple *FirstUniqued;
665 {
666 Metadata *Ops[] = {Empty};
667 auto Temp = MDTuple::getTemporary(Context, Ops);
668 EXPECT_TRUE(Temp->isTemporary());
669
670 // Don't expect a collision.
671 auto *Current = Temp.get();
672 FirstUniqued = MDNode::replaceWithUniqued(std::move(Temp));
673 EXPECT_TRUE(FirstUniqued->isUniqued());
674 EXPECT_TRUE(FirstUniqued->isResolved());
675 EXPECT_EQ(Current, FirstUniqued);
676 }
677 {
678 Metadata *Ops[] = {Empty};
679 auto Temp = MDTuple::getTemporary(Context, Ops);
680 EXPECT_TRUE(Temp->isTemporary());
681
682 // Should collide with Uniqued above this time.
683 auto *Uniqued = MDNode::replaceWithUniqued(std::move(Temp));
684 EXPECT_TRUE(Uniqued->isUniqued());
685 EXPECT_TRUE(Uniqued->isResolved());
686 EXPECT_EQ(FirstUniqued, Uniqued);
687 }
688 {
689 auto Unresolved = MDTuple::getTemporary(Context, None);
690 Metadata *Ops[] = {Unresolved.get()};
691 auto Temp = MDTuple::getTemporary(Context, Ops);
692 EXPECT_TRUE(Temp->isTemporary());
693
694 // Shouldn't be resolved.
695 auto *Uniqued = MDNode::replaceWithUniqued(std::move(Temp));
696 EXPECT_TRUE(Uniqued->isUniqued());
697 EXPECT_FALSE(Uniqued->isResolved());
698
699 // Should be a different node.
700 EXPECT_NE(FirstUniqued, Uniqued);
701
702 // Should resolve when we update its node (note: be careful to avoid a
703 // collision with any other nodes above).
704 Uniqued->replaceOperandWith(0, nullptr);
705 EXPECT_TRUE(Uniqued->isResolved());
706 }
707 }
708
709 TEST_F(MDNodeTest, replaceWithUniquedResolvingOperand) {
710 // temp !{}
711 MDTuple *Op = MDTuple::getTemporary(Context, None).release();
712 EXPECT_FALSE(Op->isResolved());
713
714 // temp !{temp !{}}
715 Metadata *Ops[] = {Op};
716 MDTuple *N = MDTuple::getTemporary(Context, Ops).release();
717 EXPECT_FALSE(N->isResolved());
718
719 // temp !{temp !{}} => !{temp !{}}
720 ASSERT_EQ(N, MDNode::replaceWithUniqued(TempMDTuple(N)));
721 EXPECT_FALSE(N->isResolved());
722
723 // !{temp !{}} => !{!{}}
724 ASSERT_EQ(Op, MDNode::replaceWithUniqued(TempMDTuple(Op)));
725 EXPECT_TRUE(Op->isResolved());
726 EXPECT_TRUE(N->isResolved());
727 }
728
729 TEST_F(MDNodeTest, replaceWithUniquedDeletedOperand) {
730 // i1* @GV
731 Type *Ty = Type::getInt1PtrTy(Context);
732 std::unique_ptr<GlobalVariable> GV(
733 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
734 ConstantAsMetadata *Op = ConstantAsMetadata::get(GV.get());
735
736 // temp !{i1* @GV}
737 Metadata *Ops[] = {Op};
738 MDTuple *N = MDTuple::getTemporary(Context, Ops).release();
739
740 // temp !{i1* @GV} => !{i1* @GV}
741 ASSERT_EQ(N, MDNode::replaceWithUniqued(TempMDTuple(N)));
742 ASSERT_TRUE(N->isUniqued());
743
744 // !{i1* @GV} => !{null}
745 GV.reset();
746 ASSERT_TRUE(N->isDistinct());
747 ASSERT_EQ(nullptr, N->getOperand(0));
748 Metadata *NullOps[] = {nullptr};
749 ASSERT_NE(N, MDTuple::get(Context, NullOps));
750 }
751
752 TEST_F(MDNodeTest, replaceWithUniquedChangedOperand) {
753 // i1* @GV
754 Type *Ty = Type::getInt1PtrTy(Context);
755 std::unique_ptr<GlobalVariable> GV(
756 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
757 ConstantAsMetadata *Op = ConstantAsMetadata::get(GV.get());
758
759 // temp !{i1* @GV}
760 Metadata *Ops[] = {Op};
761 MDTuple *N = MDTuple::getTemporary(Context, Ops).release();
762
763 // temp !{i1* @GV} => !{i1* @GV}
764 ASSERT_EQ(N, MDNode::replaceWithUniqued(TempMDTuple(N)));
765 ASSERT_TRUE(N->isUniqued());
766
767 // !{i1* @GV} => !{i1* @GV2}
768 std::unique_ptr<GlobalVariable> GV2(
769 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
770 GV->replaceAllUsesWith(GV2.get());
771 ASSERT_TRUE(N->isUniqued());
772 Metadata *NullOps[] = {ConstantAsMetadata::get(GV2.get())};
773 ASSERT_EQ(N, MDTuple::get(Context, NullOps));
774 }
775
776 TEST_F(MDNodeTest, replaceWithDistinct) {
777 {
778 auto *Empty = MDTuple::get(Context, None);
779 Metadata *Ops[] = {Empty};
780 auto Temp = MDTuple::getTemporary(Context, Ops);
781 EXPECT_TRUE(Temp->isTemporary());
782
783 // Don't expect a collision.
784 auto *Current = Temp.get();
785 auto *Distinct = MDNode::replaceWithDistinct(std::move(Temp));
786 EXPECT_TRUE(Distinct->isDistinct());
787 EXPECT_TRUE(Distinct->isResolved());
788 EXPECT_EQ(Current, Distinct);
789 }
790 {
791 auto Unresolved = MDTuple::getTemporary(Context, None);
792 Metadata *Ops[] = {Unresolved.get()};
793 auto Temp = MDTuple::getTemporary(Context, Ops);
794 EXPECT_TRUE(Temp->isTemporary());
795
796 // Don't expect a collision.
797 auto *Current = Temp.get();
798 auto *Distinct = MDNode::replaceWithDistinct(std::move(Temp));
799 EXPECT_TRUE(Distinct->isDistinct());
800 EXPECT_TRUE(Distinct->isResolved());
801 EXPECT_EQ(Current, Distinct);
802
803 // Cleanup; required for teardown.
804 Unresolved->replaceAllUsesWith(nullptr);
805 }
806 }
807
808 TEST_F(MDNodeTest, replaceWithPermanent) {
809 Metadata *Ops[] = {nullptr};
810 auto Temp = MDTuple::getTemporary(Context, Ops);
811 auto *T = Temp.get();
812
813 // U is a normal, uniqued node that references T.
814 auto *U = MDTuple::get(Context, T);
815 EXPECT_TRUE(U->isUniqued());
816
817 // Make Temp self-referencing.
818 Temp->replaceOperandWith(0, T);
819
820 // Try to uniquify Temp. This should, despite the name in the API, give a
821 // 'distinct' node, since self-references aren't allowed to be uniqued.
822 //
823 // Since it's distinct, N should have the same address as when it was a
824 // temporary (i.e., be equal to T not U).
825 auto *N = MDNode::replaceWithPermanent(std::move(Temp));
826 EXPECT_EQ(N, T);
827 EXPECT_TRUE(N->isDistinct());
828
829 // U should be the canonical unique node with N as the argument.
830 EXPECT_EQ(U, MDTuple::get(Context, N));
831 EXPECT_TRUE(U->isUniqued());
832
833 // This temporary should collide with U when replaced, but it should still be
834 // uniqued.
835 EXPECT_EQ(U, MDNode::replaceWithPermanent(MDTuple::getTemporary(Context, N)));
836 EXPECT_TRUE(U->isUniqued());
837
838 // This temporary should become a new uniqued node.
839 auto Temp2 = MDTuple::getTemporary(Context, U);
840 auto *V = Temp2.get();
841 EXPECT_EQ(V, MDNode::replaceWithPermanent(std::move(Temp2)));
842 EXPECT_TRUE(V->isUniqued());
843 EXPECT_EQ(U, V->getOperand(0));
844 }
845
846 TEST_F(MDNodeTest, deleteTemporaryWithTrackingRef) {
847 TrackingMDRef Ref;
848 EXPECT_EQ(nullptr, Ref.get());
849 {
850 auto Temp = MDTuple::getTemporary(Context, None);
851 Ref.reset(Temp.get());
852 EXPECT_EQ(Temp.get(), Ref.get());
853 }
854 EXPECT_EQ(nullptr, Ref.get());
855 }
856
857 typedef MetadataTest DILocationTest;
858
859 TEST_F(DILocationTest, Overflow) {
860 DISubprogram *N = getSubprogram();
861 {
862 DILocation *L = DILocation::get(Context, 2, 7, N);
863 EXPECT_EQ(2u, L->getLine());
864 EXPECT_EQ(7u, L->getColumn());
865 }
866 unsigned U16 = 1u << 16;
867 {
868 DILocation *L = DILocation::get(Context, UINT32_MAX, U16 - 1, N);
869 EXPECT_EQ(UINT32_MAX, L->getLine());
870 EXPECT_EQ(U16 - 1, L->getColumn());
871 }
872 {
873 DILocation *L = DILocation::get(Context, UINT32_MAX, U16, N);
874 EXPECT_EQ(UINT32_MAX, L->getLine());
875 EXPECT_EQ(0u, L->getColumn());
876 }
877 {
878 DILocation *L = DILocation::get(Context, UINT32_MAX, U16 + 1, N);
879 EXPECT_EQ(UINT32_MAX, L->getLine());
880 EXPECT_EQ(0u, L->getColumn());
881 }
882 }
883
884 TEST_F(DILocationTest, Merge) {
885 DISubprogram *N = getSubprogram();
886 DIScope *S = DILexicalBlock::get(Context, N, getFile(), 3, 4);
887
888 {
889 // Identical.
890 auto *A = DILocation::get(Context, 2, 7, N);
891 auto *B = DILocation::get(Context, 2, 7, N);
892 auto *M = DILocation::getMergedLocation(A, B);
893 EXPECT_EQ(2u, M->getLine());
894 EXPECT_EQ(7u, M->getColumn());
895 EXPECT_EQ(N, M->getScope());
896 }
897
898 {
899 // Identical, different scopes.
900 auto *A = DILocation::get(Context, 2, 7, N);
901 auto *B = DILocation::get(Context, 2, 7, S);
902 auto *M = DILocation::getMergedLocation(A, B);
903 EXPECT_EQ(0u, M->getLine()); // FIXME: Should this be 2?
904 EXPECT_EQ(0u, M->getColumn()); // FIXME: Should this be 7?
905 EXPECT_EQ(N, M->getScope());
906 }
907
908 {
909 // Different lines, same scopes.
910 auto *A = DILocation::get(Context, 1, 6, N);
911 auto *B = DILocation::get(Context, 2, 7, N);
912 auto *M = DILocation::getMergedLocation(A, B);
913 EXPECT_EQ(0u, M->getLine());
914 EXPECT_EQ(0u, M->getColumn());
915 EXPECT_EQ(N, M->getScope());
916 }
917
918 {
919 // Twisty locations, all different, same function.
920 auto *A = DILocation::get(Context, 1, 6, N);
921 auto *B = DILocation::get(Context, 2, 7, S);
922 auto *M = DILocation::getMergedLocation(A, B);
923 EXPECT_EQ(0u, M->getLine());
924 EXPECT_EQ(0u, M->getColumn());
925 EXPECT_EQ(N, M->getScope());
926 }
927
928 {
929 // Different function, same inlined-at.
930 auto *F = getFile();
931 auto *SP1 = DISubprogram::getDistinct(Context, F, "a", "a", F, 0, nullptr,
932 0, nullptr, 0, 0, DINode::FlagZero,
933 DISubprogram::SPFlagZero, nullptr);
934 auto *SP2 = DISubprogram::getDistinct(Context, F, "b", "b", F, 0, nullptr,
935 0, nullptr, 0, 0, DINode::FlagZero,
936 DISubprogram::SPFlagZero, nullptr);
937
938 auto *I = DILocation::get(Context, 2, 7, N);
939 auto *A = DILocation::get(Context, 1, 6, SP1, I);
940 auto *B = DILocation::get(Context, 2, 7, SP2, I);
941 auto *M = DILocation::getMergedLocation(A, B);
942 EXPECT_EQ(0u, M->getLine());
943 EXPECT_EQ(0u, M->getColumn());
944 EXPECT_TRUE(isa<DILocalScope>(M->getScope()));
945 EXPECT_EQ(I, M->getInlinedAt());
946 }
947
948 {
949 // Completely different.
950 auto *I = DILocation::get(Context, 2, 7, N);
951 auto *A = DILocation::get(Context, 1, 6, S, I);
952 auto *B = DILocation::get(Context, 2, 7, getSubprogram());
953 auto *M = DILocation::getMergedLocation(A, B);
954 EXPECT_EQ(0u, M->getLine());
955 EXPECT_EQ(0u, M->getColumn());
956 EXPECT_TRUE(isa<DILocalScope>(M->getScope()));
957 EXPECT_EQ(S, M->getScope());
958 EXPECT_EQ(nullptr, M->getInlinedAt());
959 }
960 }
961
962 TEST_F(DILocationTest, getDistinct) {
963 MDNode *N = getSubprogram();
964 DILocation *L0 = DILocation::getDistinct(Context, 2, 7, N);
965 EXPECT_TRUE(L0->isDistinct());
966 DILocation *L1 = DILocation::get(Context, 2, 7, N);
967 EXPECT_FALSE(L1->isDistinct());
968 EXPECT_EQ(L1, DILocation::get(Context, 2, 7, N));
969 }
970
971 TEST_F(DILocationTest, getTemporary) {
972 MDNode *N = MDNode::get(Context, None);
973 auto L = DILocation::getTemporary(Context, 2, 7, N);
974 EXPECT_TRUE(L->isTemporary());
975 EXPECT_FALSE(L->isResolved());
976 }
977
978 TEST_F(DILocationTest, cloneTemporary) {
979 MDNode *N = MDNode::get(Context, None);
980 auto L = DILocation::getTemporary(Context, 2, 7, N);
981 EXPECT_TRUE(L->isTemporary());
982 auto L2 = L->clone();
983 EXPECT_TRUE(L2->isTemporary());
984 }
985
986 typedef MetadataTest GenericDINodeTest;
987
988 TEST_F(GenericDINodeTest, get) {
989 StringRef Header = "header";
990 auto *Empty = MDNode::get(Context, None);
991 Metadata *Ops1[] = {Empty};
992 auto *N = GenericDINode::get(Context, 15, Header, Ops1);
993 EXPECT_EQ(15u, N->getTag());
994 EXPECT_EQ(2u, N->getNumOperands());
995 EXPECT_EQ(Header, N->getHeader());
996 EXPECT_EQ(MDString::get(Context, Header), N->getOperand(0));
997 EXPECT_EQ(1u, N->getNumDwarfOperands());
998 EXPECT_EQ(Empty, N->getDwarfOperand(0));
999 EXPECT_EQ(Empty, N->getOperand(1));
1000 ASSERT_TRUE(N->isUniqued());
1001
1002 EXPECT_EQ(N, GenericDINode::get(Context, 15, Header, Ops1));
1003
1004 N->replaceOperandWith(1, nullptr);
1005 EXPECT_EQ(15u, N->getTag());
1006 EXPECT_EQ(Header, N->getHeader());
1007 EXPECT_EQ(nullptr, N->getDwarfOperand(0));
1008 ASSERT_TRUE(N->isUniqued());
1009
1010 Metadata *Ops2[] = {nullptr};
1011 EXPECT_EQ(N, GenericDINode::get(Context, 15, Header, Ops2));
1012
1013 N->replaceDwarfOperandWith(0, Empty);
1014 EXPECT_EQ(15u, N->getTag());
1015 EXPECT_EQ(Header, N->getHeader());
1016 EXPECT_EQ(Empty, N->getDwarfOperand(0));
1017 ASSERT_TRUE(N->isUniqued());
1018 EXPECT_EQ(N, GenericDINode::get(Context, 15, Header, Ops1));
1019
1020 TempGenericDINode Temp = N->clone();
1021 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1022 }
1023
1024 TEST_F(GenericDINodeTest, getEmptyHeader) {
1025 // Canonicalize !"" to null.
1026 auto *N = GenericDINode::get(Context, 15, StringRef(), None);
1027 EXPECT_EQ(StringRef(), N->getHeader());
1028 EXPECT_EQ(nullptr, N->getOperand(0));
1029 }
1030
1031 typedef MetadataTest DISubrangeTest;
1032
1033 TEST_F(DISubrangeTest, get) {
1034 auto *N = DISubrange::get(Context, 5, 7);
1035 auto Count = N->getCount();
1036 EXPECT_EQ(dwarf::DW_TAG_subrange_type, N->getTag());
1037 ASSERT_TRUE(Count);
1038 ASSERT_TRUE(Count.is<ConstantInt*>());
1039 EXPECT_EQ(5, Count.get<ConstantInt*>()->getSExtValue());
1040 EXPECT_EQ(7, N->getLowerBound());
1041 EXPECT_EQ(N, DISubrange::get(Context, 5, 7));
1042 EXPECT_EQ(DISubrange::get(Context, 5, 0), DISubrange::get(Context, 5));
1043
1044 TempDISubrange Temp = N->clone();
1045 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1046 }
1047
1048 TEST_F(DISubrangeTest, getEmptyArray) {
1049 auto *N = DISubrange::get(Context, -1, 0);
1050 auto Count = N->getCount();
1051 EXPECT_EQ(dwarf::DW_TAG_subrange_type, N->getTag());
1052 ASSERT_TRUE(Count);
1053 ASSERT_TRUE(Count.is<ConstantInt*>());
1054 EXPECT_EQ(-1, Count.get<ConstantInt*>()->getSExtValue());
1055 EXPECT_EQ(0, N->getLowerBound());
1056 EXPECT_EQ(N, DISubrange::get(Context, -1, 0));
1057 }
1058
1059 TEST_F(DISubrangeTest, getVariableCount) {
1060 DILocalScope *Scope = getSubprogram();
1061 DIFile *File = getFile();
1062 DIType *Type = getDerivedType();
1063 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(7);
1064 auto *VlaExpr = DILocalVariable::get(Context, Scope, "vla_expr", File, 8,
1065 Type, 2, Flags, 8);
1066
1067 auto *N = DISubrange::get(Context, VlaExpr, 0);
1068 auto Count = N->getCount();
1069 ASSERT_TRUE(Count);
1070 ASSERT_TRUE(Count.is<DIVariable*>());
1071 EXPECT_EQ(VlaExpr, Count.get<DIVariable*>());
1072 ASSERT_TRUE(isa<DIVariable>(N->getRawCountNode()));
1073 EXPECT_EQ(0, N->getLowerBound());
1074 EXPECT_EQ("vla_expr", Count.get<DIVariable*>()->getName());
1075 EXPECT_EQ(N, DISubrange::get(Context, VlaExpr, 0));
1076 }
1077
1078 typedef MetadataTest DIEnumeratorTest;
1079
1080 TEST_F(DIEnumeratorTest, get) {
1081 auto *N = DIEnumerator::get(Context, 7, false, "name");
1082 EXPECT_EQ(dwarf::DW_TAG_enumerator, N->getTag());
1083 EXPECT_EQ(7, N->getValue());
1084 EXPECT_FALSE(N->isUnsigned());
1085 EXPECT_EQ("name", N->getName());
1086 EXPECT_EQ(N, DIEnumerator::get(Context, 7, false, "name"));
1087
1088 EXPECT_NE(N, DIEnumerator::get(Context, 7, true, "name"));
1089 EXPECT_NE(N, DIEnumerator::get(Context, 8, false, "name"));
1090 EXPECT_NE(N, DIEnumerator::get(Context, 7, false, "nam"));
1091
1092 TempDIEnumerator Temp = N->clone();
1093 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1094 }
1095
1096 typedef MetadataTest DIBasicTypeTest;
1097
1098 TEST_F(DIBasicTypeTest, get) {
1099 auto *N =
1100 DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33, 26, 7,
1101 DINode::FlagZero);
1102 EXPECT_EQ(dwarf::DW_TAG_base_type, N->getTag());
1103 EXPECT_EQ("special", N->getName());
1104 EXPECT_EQ(33u, N->getSizeInBits());
1105 EXPECT_EQ(26u, N->getAlignInBits());
1106 EXPECT_EQ(7u, N->getEncoding());
1107 EXPECT_EQ(0u, N->getLine());
1108 EXPECT_EQ(DINode::FlagZero, N->getFlags());
1109 EXPECT_EQ(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
1110 26, 7, DINode::FlagZero));
1111
1112 EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type,
1113 "special", 33, 26, 7, DINode::FlagZero));
1114 EXPECT_NE(N,
1115 DIBasicType::get(Context, dwarf::DW_TAG_base_type, "s", 33, 26, 7,
1116 DINode::FlagZero));
1117 EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 32,
1118 26, 7, DINode::FlagZero));
1119 EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
1120 25, 7, DINode::FlagZero));
1121 EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
1122 26, 6, DINode::FlagZero));
1123 EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
1124 26, 7, DINode::FlagBigEndian));
1125 EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
1126 26, 7, DINode::FlagLittleEndian));
1127
1128 TempDIBasicType Temp = N->clone();
1129 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1130 }
1131
1132 TEST_F(DIBasicTypeTest, getWithLargeValues) {
1133 auto *N = DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special",
1134 UINT64_MAX, UINT32_MAX - 1, 7, DINode::FlagZero);
1135 EXPECT_EQ(UINT64_MAX, N->getSizeInBits());
1136 EXPECT_EQ(UINT32_MAX - 1, N->getAlignInBits());
1137 }
1138
1139 TEST_F(DIBasicTypeTest, getUnspecified) {
1140 auto *N =
1141 DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type, "unspecified");
1142 EXPECT_EQ(dwarf::DW_TAG_unspecified_type, N->getTag());
1143 EXPECT_EQ("unspecified", N->getName());
1144 EXPECT_EQ(0u, N->getSizeInBits());
1145 EXPECT_EQ(0u, N->getAlignInBits());
1146 EXPECT_EQ(0u, N->getEncoding());
1147 EXPECT_EQ(0u, N->getLine());
1148 EXPECT_EQ(DINode::FlagZero, N->getFlags());
1149 }
1150
1151 typedef MetadataTest DITypeTest;
1152
1153 TEST_F(DITypeTest, clone) {
1154 // Check that DIType has a specialized clone that returns TempDIType.
1155 DIType *N = DIBasicType::get(Context, dwarf::DW_TAG_base_type, "int", 32, 32,
1156 dwarf::DW_ATE_signed, DINode::FlagZero);
1157
1158 TempDIType Temp = N->clone();
1159 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1160 }
1161
1162 TEST_F(DITypeTest, cloneWithFlags) {
1163 // void (void)
1164 Metadata *TypesOps[] = {nullptr};
1165 Metadata *Types = MDTuple::get(Context, TypesOps);
1166
1167 DIType *D =
1168 DISubroutineType::getDistinct(Context, DINode::FlagZero, 0, Types);
1169 EXPECT_EQ(DINode::FlagZero, D->getFlags());
1170 TempDIType D2 = D->cloneWithFlags(DINode::FlagRValueReference);
1171 EXPECT_EQ(DINode::FlagRValueReference, D2->getFlags());
1172 EXPECT_EQ(DINode::FlagZero, D->getFlags());
1173
1174 TempDIType T =
1175 DISubroutineType::getTemporary(Context, DINode::FlagZero, 0, Types);
1176 EXPECT_EQ(DINode::FlagZero, T->getFlags());
1177 TempDIType T2 = T->cloneWithFlags(DINode::FlagRValueReference);
1178 EXPECT_EQ(DINode::FlagRValueReference, T2->getFlags());
1179 EXPECT_EQ(DINode::FlagZero, T->getFlags());
1180 }
1181
1182 typedef MetadataTest DIDerivedTypeTest;
1183
1184 TEST_F(DIDerivedTypeTest, get) {
1185 DIFile *File = getFile();
1186 DIScope *Scope = getSubprogram();
1187 DIType *BaseType = getBasicType("basic");
1188 MDTuple *ExtraData = getTuple();
1189 unsigned DWARFAddressSpace = 8;
1190 DINode::DIFlags Flags5 = static_cast<DINode::DIFlags>(5);
1191 DINode::DIFlags Flags4 = static_cast<DINode::DIFlags>(4);
1192
1193 auto *N =
1194 DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something", File,
1195 1, Scope, BaseType, 2, 3, 4, DWARFAddressSpace, Flags5,
1196 ExtraData);
1197 EXPECT_EQ(dwarf::DW_TAG_pointer_type, N->getTag());
1198 EXPECT_EQ("something", N->getName());
1199 EXPECT_EQ(File, N->getFile());
1200 EXPECT_EQ(1u, N->getLine());
1201 EXPECT_EQ(Scope, N->getScope());
1202 EXPECT_EQ(BaseType, N->getBaseType());
1203 EXPECT_EQ(2u, N->getSizeInBits());
1204 EXPECT_EQ(3u, N->getAlignInBits());
1205 EXPECT_EQ(4u, N->getOffsetInBits());
1206 EXPECT_EQ(DWARFAddressSpace, N->getDWARFAddressSpace().getValue());
1207 EXPECT_EQ(5u, N->getFlags());
1208 EXPECT_EQ(ExtraData, N->getExtraData());
1209 EXPECT_EQ(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
1210 "something", File, 1, Scope, BaseType, 2, 3,
1211 4, DWARFAddressSpace, Flags5, ExtraData));
1212
1213 EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_reference_type,
1214 "something", File, 1, Scope, BaseType, 2, 3,
1215 4, DWARFAddressSpace, Flags5, ExtraData));
1216 EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "else",
1217 File, 1, Scope, BaseType, 2, 3,
1218 4, DWARFAddressSpace, Flags5, ExtraData));
1219 EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
1220 "something", getFile(), 1, Scope, BaseType, 2,
1221 3, 4, DWARFAddressSpace, Flags5, ExtraData));
1222 EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
1223 "something", File, 2, Scope, BaseType, 2, 3,
1224 4, DWARFAddressSpace, Flags5, ExtraData));
1225 EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
1226 "something", File, 1, getSubprogram(),
1227 BaseType, 2, 3, 4, DWARFAddressSpace, Flags5,
1228 ExtraData));
1229 EXPECT_NE(N, DIDerivedType::get(
1230 Context, dwarf::DW_TAG_pointer_type, "something", File, 1,
1231 Scope, getBasicType("basic2"), 2, 3, 4, DWARFAddressSpace,
1232 Flags5, ExtraData));
1233 EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
1234 "something", File, 1, Scope, BaseType, 3, 3,
1235 4, DWARFAddressSpace, Flags5, ExtraData));
1236 EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
1237 "something", File, 1, Scope, BaseType, 2, 2,
1238 4, DWARFAddressSpace, Flags5, ExtraData));
1239 EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
1240 "something", File, 1, Scope, BaseType, 2, 3,
1241 5, DWARFAddressSpace, Flags5, ExtraData));
1242 EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
1243 "something", File, 1, Scope, BaseType, 2, 3,
1244 4, DWARFAddressSpace + 1, Flags5, ExtraData));
1245 EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
1246 "something", File, 1, Scope, BaseType, 2, 3,
1247 4, DWARFAddressSpace, Flags4, ExtraData));
1248 EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
1249 "something", File, 1, Scope, BaseType, 2, 3,
1250 4, DWARFAddressSpace, Flags5, getTuple()));
1251
1252 TempDIDerivedType Temp = N->clone();
1253 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1254 }
1255
1256 TEST_F(DIDerivedTypeTest, getWithLargeValues) {
1257 DIFile *File = getFile();
1258 DIScope *Scope = getSubprogram();
1259 DIType *BaseType = getBasicType("basic");
1260 MDTuple *ExtraData = getTuple();
1261 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
1262
1263 auto *N = DIDerivedType::get(
1264 Context, dwarf::DW_TAG_pointer_type, "something", File, 1, Scope,
1265 BaseType, UINT64_MAX, UINT32_MAX - 1, UINT64_MAX - 2, UINT32_MAX - 3,
1266 Flags, ExtraData);
1267 EXPECT_EQ(UINT64_MAX, N->getSizeInBits());
1268 EXPECT_EQ(UINT32_MAX - 1, N->getAlignInBits());
1269 EXPECT_EQ(UINT64_MAX - 2, N->getOffsetInBits());
1270 EXPECT_EQ(UINT32_MAX - 3, N->getDWARFAddressSpace().getValue());
1271 }
1272
1273 typedef MetadataTest DICompositeTypeTest;
1274
1275 TEST_F(DICompositeTypeTest, get) {
1276 unsigned Tag = dwarf::DW_TAG_structure_type;
1277 StringRef Name = "some name";
1278 DIFile *File = getFile();
1279 unsigned Line = 1;
1280 DIScope *Scope = getSubprogram();
1281 DIType *BaseType = getCompositeType();
1282 uint64_t SizeInBits = 2;
1283 uint32_t AlignInBits = 3;
1284 uint64_t OffsetInBits = 4;
1285 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
1286 MDTuple *Elements = getTuple();
1287 unsigned RuntimeLang = 6;
1288 DIType *VTableHolder = getCompositeType();
1289 MDTuple *TemplateParams = getTuple();
1290 StringRef Identifier = "some id";
1291
1292 auto *N = DICompositeType::get(Context, Tag, Name, File, Line, Scope,
1293 BaseType, SizeInBits, AlignInBits,
1294 OffsetInBits, Flags, Elements, RuntimeLang,
1295 VTableHolder, TemplateParams, Identifier);
1296 EXPECT_EQ(Tag, N->getTag());
1297 EXPECT_EQ(Name, N->getName());
1298 EXPECT_EQ(File, N->getFile());
1299 EXPECT_EQ(Line, N->getLine());
1300 EXPECT_EQ(Scope, N->getScope());
1301 EXPECT_EQ(BaseType, N->getBaseType());
1302 EXPECT_EQ(SizeInBits, N->getSizeInBits());
1303 EXPECT_EQ(AlignInBits, N->getAlignInBits());
1304 EXPECT_EQ(OffsetInBits, N->getOffsetInBits());
1305 EXPECT_EQ(Flags, N->getFlags());
1306 EXPECT_EQ(Elements, N->getElements().get());
1307 EXPECT_EQ(RuntimeLang, N->getRuntimeLang());
1308 EXPECT_EQ(VTableHolder, N->getVTableHolder());
1309 EXPECT_EQ(TemplateParams, N->getTemplateParams().get());
1310 EXPECT_EQ(Identifier, N->getIdentifier());
1311
1312 EXPECT_EQ(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,
1313 BaseType, SizeInBits, AlignInBits,
1314 OffsetInBits, Flags, Elements, RuntimeLang,
1315 VTableHolder, TemplateParams, Identifier));
1316
1317 EXPECT_NE(N, DICompositeType::get(Context, Tag + 1, Name, File, Line, Scope,
1318 BaseType, SizeInBits, AlignInBits,
1319 OffsetInBits, Flags, Elements, RuntimeLang,
1320 VTableHolder, TemplateParams, Identifier));
1321 EXPECT_NE(N, DICompositeType::get(Context, Tag, "abc", File, Line, Scope,
1322 BaseType, SizeInBits, AlignInBits,
1323 OffsetInBits, Flags, Elements, RuntimeLang,
1324 VTableHolder, TemplateParams, Identifier));
1325 EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, getFile(), Line, Scope,
1326 BaseType, SizeInBits, AlignInBits,
1327 OffsetInBits, Flags, Elements, RuntimeLang,
1328 VTableHolder, TemplateParams, Identifier));
1329 EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, File, Line + 1, Scope,
1330 BaseType, SizeInBits, AlignInBits,
1331 OffsetInBits, Flags, Elements, RuntimeLang,
1332 VTableHolder, TemplateParams, Identifier));
1333 EXPECT_NE(N, DICompositeType::get(
1334 Context, Tag, Name, File, Line, getSubprogram(), BaseType,
1335 SizeInBits, AlignInBits, OffsetInBits, Flags, Elements,
1336 RuntimeLang, VTableHolder, TemplateParams, Identifier));
1337 EXPECT_NE(N, DICompositeType::get(
1338 Context, Tag, Name, File, Line, Scope, getBasicType("other"),
1339 SizeInBits, AlignInBits, OffsetInBits, Flags, Elements,
1340 RuntimeLang, VTableHolder, TemplateParams, Identifier));
1341 EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,
1342 BaseType, SizeInBits + 1, AlignInBits,
1343 OffsetInBits, Flags, Elements, RuntimeLang,
1344 VTableHolder, TemplateParams, Identifier));
1345 EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,
1346 BaseType, SizeInBits, AlignInBits + 1,
1347 OffsetInBits, Flags, Elements, RuntimeLang,
1348 VTableHolder, TemplateParams, Identifier));
1349 EXPECT_NE(N, DICompositeType::get(
1350 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
1351 AlignInBits, OffsetInBits + 1, Flags, Elements, RuntimeLang,
1352 VTableHolder, TemplateParams, Identifier));
1353 DINode::DIFlags FlagsPOne = static_cast<DINode::DIFlags>(Flags + 1);
1354 EXPECT_NE(N, DICompositeType::get(
1355 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
1356 AlignInBits, OffsetInBits, FlagsPOne, Elements, RuntimeLang,
1357 VTableHolder, TemplateParams, Identifier));
1358 EXPECT_NE(N, DICompositeType::get(
1359 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
1360 AlignInBits, OffsetInBits, Flags, getTuple(), RuntimeLang,
1361 VTableHolder, TemplateParams, Identifier));
1362 EXPECT_NE(N, DICompositeType::get(
1363 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
1364 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang + 1,
1365 VTableHolder, TemplateParams, Identifier));
1366 EXPECT_NE(N, DICompositeType::get(
1367 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
1368 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
1369 getCompositeType(), TemplateParams, Identifier));
1370 EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,
1371 BaseType, SizeInBits, AlignInBits,
1372 OffsetInBits, Flags, Elements, RuntimeLang,
1373 VTableHolder, getTuple(), Identifier));
1374 EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,
1375 BaseType, SizeInBits, AlignInBits,
1376 OffsetInBits, Flags, Elements, RuntimeLang,
1377 VTableHolder, TemplateParams, "other"));
1378
1379 // Be sure that missing identifiers get null pointers.
1380 EXPECT_FALSE(DICompositeType::get(Context, Tag, Name, File, Line, Scope,
1381 BaseType, SizeInBits, AlignInBits,
1382 OffsetInBits, Flags, Elements, RuntimeLang,
1383 VTableHolder, TemplateParams, "")
1384 ->getRawIdentifier());
1385 EXPECT_FALSE(DICompositeType::get(Context, Tag, Name, File, Line, Scope,
1386 BaseType, SizeInBits, AlignInBits,
1387 OffsetInBits, Flags, Elements, RuntimeLang,
1388 VTableHolder, TemplateParams)
1389 ->getRawIdentifier());
1390
1391 TempDICompositeType Temp = N->clone();
1392 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1393 }
1394
1395 TEST_F(DICompositeTypeTest, getWithLargeValues) {
1396 unsigned Tag = dwarf::DW_TAG_structure_type;
1397 StringRef Name = "some name";
1398 DIFile *File = getFile();
1399 unsigned Line = 1;
1400 DIScope *Scope = getSubprogram();
1401 DIType *BaseType = getCompositeType();
1402 uint64_t SizeInBits = UINT64_MAX;
1403 uint32_t AlignInBits = UINT32_MAX - 1;
1404 uint64_t OffsetInBits = UINT64_MAX - 2;
1405 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
1406 MDTuple *Elements = getTuple();
1407 unsigned RuntimeLang = 6;
1408 DIType *VTableHolder = getCompositeType();
1409 MDTuple *TemplateParams = getTuple();
1410 StringRef Identifier = "some id";
1411
1412 auto *N = DICompositeType::get(Context, Tag, Name, File, Line, Scope,
1413 BaseType, SizeInBits, AlignInBits,
1414 OffsetInBits, Flags, Elements, RuntimeLang,
1415 VTableHolder, TemplateParams, Identifier);
1416 EXPECT_EQ(SizeInBits, N->getSizeInBits());
1417 EXPECT_EQ(AlignInBits, N->getAlignInBits());
1418 EXPECT_EQ(OffsetInBits, N->getOffsetInBits());
1419 }
1420
1421 TEST_F(DICompositeTypeTest, replaceOperands) {
1422 unsigned Tag = dwarf::DW_TAG_structure_type;
1423 StringRef Name = "some name";
1424 DIFile *File = getFile();
1425 unsigned Line = 1;
1426 DIScope *Scope = getSubprogram();
1427 DIType *BaseType = getCompositeType();
1428 uint64_t SizeInBits = 2;
1429 uint32_t AlignInBits = 3;
1430 uint64_t OffsetInBits = 4;
1431 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
1432 unsigned RuntimeLang = 6;
1433 StringRef Identifier = "some id";
1434
1435 auto *N = DICompositeType::get(
1436 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits,
1437 OffsetInBits, Flags, nullptr, RuntimeLang, nullptr, nullptr, Identifier);
1438
1439 auto *Elements = MDTuple::getDistinct(Context, None);
1440 EXPECT_EQ(nullptr, N->getElements().get());
1441 N->replaceElements(Elements);
1442 EXPECT_EQ(Elements, N->getElements().get());
1443 N->replaceElements(nullptr);
1444 EXPECT_EQ(nullptr, N->getElements().get());
1445
1446 DIType *VTableHolder = getCompositeType();
1447 EXPECT_EQ(nullptr, N->getVTableHolder());
1448 N->replaceVTableHolder(VTableHolder);
1449 EXPECT_EQ(VTableHolder, N->getVTableHolder());
1450 // As an extension, the containing type can be anything. This is
1451 // used by Rust to associate vtables with their concrete type.
1452 DIType *BasicType = getBasicType("basic");
1453 N->replaceVTableHolder(BasicType);
1454 EXPECT_EQ(BasicType, N->getVTableHolder());
1455 N->replaceVTableHolder(nullptr);
1456 EXPECT_EQ(nullptr, N->getVTableHolder());
1457
1458 auto *TemplateParams = MDTuple::getDistinct(Context, None);
1459 EXPECT_EQ(nullptr, N->getTemplateParams().get());
1460 N->replaceTemplateParams(TemplateParams);
1461 EXPECT_EQ(TemplateParams, N->getTemplateParams().get());
1462 N->replaceTemplateParams(nullptr);
1463 EXPECT_EQ(nullptr, N->getTemplateParams().get());
1464 }
1465
1466 TEST_F(DICompositeTypeTest, variant_part) {
1467 unsigned Tag = dwarf::DW_TAG_variant_part;
1468 StringRef Name = "some name";
1469 DIFile *File = getFile();
1470 unsigned Line = 1;
1471 DIScope *Scope = getSubprogram();
1472 DIType *BaseType = getCompositeType();
1473 uint64_t SizeInBits = 2;
1474 uint32_t AlignInBits = 3;
1475 uint64_t OffsetInBits = 4;
1476 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
1477 unsigned RuntimeLang = 6;
1478 StringRef Identifier = "some id";
1479 DIDerivedType *Discriminator = cast<DIDerivedType>(getDerivedType());
1480 DIDerivedType *Discriminator2 = cast<DIDerivedType>(getDerivedType());
1481
1482 EXPECT_NE(Discriminator, Discriminator2);
1483
1484 auto *N = DICompositeType::get(
1485 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits,
1486 OffsetInBits, Flags, nullptr, RuntimeLang, nullptr, nullptr, Identifier,
1487 Discriminator);
1488
1489 // Test the hashing.
1490 auto *Same = DICompositeType::get(
1491 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits,
1492 OffsetInBits, Flags, nullptr, RuntimeLang, nullptr, nullptr, Identifier,
1493 Discriminator);
1494 auto *Other = DICompositeType::get(
1495 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits,
1496 OffsetInBits, Flags, nullptr, RuntimeLang, nullptr, nullptr, Identifier,
1497 Discriminator2);
1498 auto *NoDisc = DICompositeType::get(
1499 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits,
1500 OffsetInBits, Flags, nullptr, RuntimeLang, nullptr, nullptr, Identifier,
1501 nullptr);
1502
1503 EXPECT_EQ(N, Same);
1504 EXPECT_NE(Same, Other);
1505 EXPECT_NE(Same, NoDisc);
1506 EXPECT_NE(Other, NoDisc);
1507
1508 EXPECT_EQ(N->getDiscriminator(), Discriminator);
1509 }
1510
1511 typedef MetadataTest DISubroutineTypeTest;
1512
1513 TEST_F(DISubroutineTypeTest, get) {
1514 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(1);
1515 DINode::DIFlags FlagsPOne = static_cast<DINode::DIFlags>(Flags + 1);
1516 MDTuple *TypeArray = getTuple();
1517
1518 auto *N = DISubroutineType::get(Context, Flags, 0, TypeArray);
1519 EXPECT_EQ(dwarf::DW_TAG_subroutine_type, N->getTag());
1520 EXPECT_EQ(Flags, N->getFlags());
1521 EXPECT_EQ(TypeArray, N->getTypeArray().get());
1522 EXPECT_EQ(N, DISubroutineType::get(Context, Flags, 0, TypeArray));
1523
1524 EXPECT_NE(N, DISubroutineType::get(Context, FlagsPOne, 0, TypeArray));
1525 EXPECT_NE(N, DISubroutineType::get(Context, Flags, 0, getTuple()));
1526
1527 // Test the hashing of calling conventions.
1528 auto *Fast = DISubroutineType::get(
1529 Context, Flags, dwarf::DW_CC_BORLAND_msfastcall, TypeArray);
1530 auto *Std = DISubroutineType::get(Context, Flags,
1531 dwarf::DW_CC_BORLAND_stdcall, TypeArray);
1532 EXPECT_EQ(Fast,
1533 DISubroutineType::get(Context, Flags,
1534 dwarf::DW_CC_BORLAND_msfastcall, TypeArray));
1535 EXPECT_EQ(Std, DISubroutineType::get(
1536 Context, Flags, dwarf::DW_CC_BORLAND_stdcall, TypeArray));
1537
1538 EXPECT_NE(N, Fast);
1539 EXPECT_NE(N, Std);
1540 EXPECT_NE(Fast, Std);
1541
1542 TempDISubroutineType Temp = N->clone();
1543 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1544
1545 // Test always-empty operands.
1546 EXPECT_EQ(nullptr, N->getScope());
1547 EXPECT_EQ(nullptr, N->getFile());
1548 EXPECT_EQ("", N->getName());
1549 }
1550
1551 typedef MetadataTest DIFileTest;
1552
1553 TEST_F(DIFileTest, get) {
1554 StringRef Filename = "file";
1555 StringRef Directory = "dir";
1556 DIFile::ChecksumKind CSKind = DIFile::ChecksumKind::CSK_MD5;
1557 StringRef ChecksumString = "000102030405060708090a0b0c0d0e0f";
1558 DIFile::ChecksumInfo<StringRef> Checksum(CSKind, ChecksumString);
1559 StringRef Source = "source";
1560 auto *N = DIFile::get(Context, Filename, Directory, Checksum, Source);
1561
1562 EXPECT_EQ(dwarf::DW_TAG_file_type, N->getTag());
1563 EXPECT_EQ(Filename, N->getFilename());
1564 EXPECT_EQ(Directory, N->getDirectory());
1565 EXPECT_EQ(Checksum, N->getChecksum());
1566 EXPECT_EQ(Source, N->getSource());
1567 EXPECT_EQ(N, DIFile::get(Context, Filename, Directory, Checksum, Source));
1568
1569 EXPECT_NE(N, DIFile::get(Context, "other", Directory, Checksum, Source));
1570 EXPECT_NE(N, DIFile::get(Context, Filename, "other", Checksum, Source));
1571 DIFile::ChecksumInfo<StringRef> OtherChecksum(DIFile::ChecksumKind::CSK_SHA1, ChecksumString);
1572 EXPECT_NE(
1573 N, DIFile::get(Context, Filename, Directory, OtherChecksum));
1574 StringRef OtherSource = "other";
1575 EXPECT_NE(N, DIFile::get(Context, Filename, Directory, Checksum, OtherSource));
1576 EXPECT_NE(N, DIFile::get(Context, Filename, Directory, Checksum));
1577 EXPECT_NE(N, DIFile::get(Context, Filename, Directory));
1578
1579 TempDIFile Temp = N->clone();
1580 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1581 }
1582
1583 TEST_F(DIFileTest, ScopeGetFile) {
1584 // Ensure that DIScope::getFile() returns itself.
1585 DIScope *N = DIFile::get(Context, "file", "dir");
1586 EXPECT_EQ(N, N->getFile());
1587 }
1588
1589 typedef MetadataTest DICompileUnitTest;
1590
1591 TEST_F(DICompileUnitTest, get) {
1592 unsigned SourceLanguage = 1;
1593 DIFile *File = getFile();
1594 StringRef Producer = "some producer";
1595 bool IsOptimized = false;
1596 StringRef Flags = "flag after flag";
1597 unsigned RuntimeVersion = 2;
1598 StringRef SplitDebugFilename = "another/file";
1599 auto EmissionKind = DICompileUnit::FullDebug;
1600 MDTuple *EnumTypes = getTuple();
1601 MDTuple *RetainedTypes = getTuple();
1602 MDTuple *GlobalVariables = getTuple();
1603 MDTuple *ImportedEntities = getTuple();
1604 uint64_t DWOId = 0x10000000c0ffee;
1605 MDTuple *Macros = getTuple();
1606 auto *N = DICompileUnit::getDistinct(
1607 Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1608 RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1609 RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId, true,
1610 false, DICompileUnit::DebugNameTableKind::Default, false);
1611
1612 EXPECT_EQ(dwarf::DW_TAG_compile_unit, N->getTag());
1613 EXPECT_EQ(SourceLanguage, N->getSourceLanguage());
1614 EXPECT_EQ(File, N->getFile());
1615 EXPECT_EQ(Producer, N->getProducer());
1616 EXPECT_EQ(IsOptimized, N->isOptimized());
1617 EXPECT_EQ(Flags, N->getFlags());
1618 EXPECT_EQ(RuntimeVersion, N->getRuntimeVersion());
1619 EXPECT_EQ(SplitDebugFilename, N->getSplitDebugFilename());
1620 EXPECT_EQ(EmissionKind, N->getEmissionKind());
1621 EXPECT_EQ(EnumTypes, N->getEnumTypes().get());
1622 EXPECT_EQ(RetainedTypes, N->getRetainedTypes().get());
1623 EXPECT_EQ(GlobalVariables, N->getGlobalVariables().get());
1624 EXPECT_EQ(ImportedEntities, N->getImportedEntities().get());
1625 EXPECT_EQ(Macros, N->getMacros().get());
1626 EXPECT_EQ(DWOId, N->getDWOId());
1627
1628 TempDICompileUnit Temp = N->clone();
1629 EXPECT_EQ(dwarf::DW_TAG_compile_unit, Temp->getTag());
1630 EXPECT_EQ(SourceLanguage, Temp->getSourceLanguage());
1631 EXPECT_EQ(File, Temp->getFile());
1632 EXPECT_EQ(Producer, Temp->getProducer());
1633 EXPECT_EQ(IsOptimized, Temp->isOptimized());
1634 EXPECT_EQ(Flags, Temp->getFlags());
1635 EXPECT_EQ(RuntimeVersion, Temp->getRuntimeVersion());
1636 EXPECT_EQ(SplitDebugFilename, Temp->getSplitDebugFilename());
1637 EXPECT_EQ(EmissionKind, Temp->getEmissionKind());
1638 EXPECT_EQ(EnumTypes, Temp->getEnumTypes().get());
1639 EXPECT_EQ(RetainedTypes, Temp->getRetainedTypes().get());
1640 EXPECT_EQ(GlobalVariables, Temp->getGlobalVariables().get());
1641 EXPECT_EQ(ImportedEntities, Temp->getImportedEntities().get());
1642 EXPECT_EQ(Macros, Temp->getMacros().get());
1643 EXPECT_EQ(DWOId, Temp->getDWOId());
1644
1645 auto *TempAddress = Temp.get();
1646 auto *Clone = MDNode::replaceWithPermanent(std::move(Temp));
1647 EXPECT_TRUE(Clone->isDistinct());
1648 EXPECT_EQ(TempAddress, Clone);
1649 }
1650
1651 TEST_F(DICompileUnitTest, replaceArrays) {
1652 unsigned SourceLanguage = 1;
1653 DIFile *File = getFile();
1654 StringRef Producer = "some producer";
1655 bool IsOptimized = false;
1656 StringRef Flags = "flag after flag";
1657 unsigned RuntimeVersion = 2;
1658 StringRef SplitDebugFilename = "another/file";
1659 auto EmissionKind = DICompileUnit::FullDebug;
1660 MDTuple *EnumTypes = MDTuple::getDistinct(Context, None);
1661 MDTuple *RetainedTypes = MDTuple::getDistinct(Context, None);
1662 MDTuple *ImportedEntities = MDTuple::getDistinct(Context, None);
1663 uint64_t DWOId = 0xc0ffee;
1664 auto *N = DICompileUnit::getDistinct(
1665 Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1666 RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1667 RetainedTypes, nullptr, ImportedEntities, nullptr, DWOId, true, false,
1668 DICompileUnit::DebugNameTableKind::Default, false);
1669
1670 auto *GlobalVariables = MDTuple::getDistinct(Context, None);
1671 EXPECT_EQ(nullptr, N->getGlobalVariables().get());
1672 N->replaceGlobalVariables(GlobalVariables);
1673 EXPECT_EQ(GlobalVariables, N->getGlobalVariables().get());
1674 N->replaceGlobalVariables(nullptr);
1675 EXPECT_EQ(nullptr, N->getGlobalVariables().get());
1676
1677 auto *Macros = MDTuple::getDistinct(Context, None);
1678 EXPECT_EQ(nullptr, N->getMacros().get());
1679 N->replaceMacros(Macros);
1680 EXPECT_EQ(Macros, N->getMacros().get());
1681 N->replaceMacros(nullptr);
1682 EXPECT_EQ(nullptr, N->getMacros().get());
1683 }
1684
1685 typedef MetadataTest DISubprogramTest;
1686
1687 TEST_F(DISubprogramTest, get) {
1688 DIScope *Scope = getCompositeType();
1689 StringRef Name = "name";
1690 StringRef LinkageName = "linkage";
1691 DIFile *File = getFile();
1692 unsigned Line = 2;
1693 DISubroutineType *Type = getSubroutineType();
1694 bool IsLocalToUnit = false;
1695 bool IsDefinition = true;
1696 unsigned ScopeLine = 3;
1697 DIType *ContainingType = getCompositeType();
1698 unsigned Virtuality = 2;
1699 unsigned VirtualIndex = 5;
1700 int ThisAdjustment = -3;
1701 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(6);
1702 bool IsOptimized = false;
1703 MDTuple *TemplateParams = getTuple();
1704 DISubprogram *Declaration = getSubprogram();
1705 MDTuple *RetainedNodes = getTuple();
1706 MDTuple *ThrownTypes = getTuple();
1707 DICompileUnit *Unit = getUnit();
1708 DISubprogram::DISPFlags SPFlags =
1709 static_cast<DISubprogram::DISPFlags>(Virtuality);
1710 assert(!IsLocalToUnit && IsDefinition && !IsOptimized &&
1711 "bools and SPFlags have to match");
1712 SPFlags |= DISubprogram::SPFlagDefinition;
1713
1714 auto *N = DISubprogram::get(
1715 Context, Scope, Name, LinkageName, File, Line, Type, ScopeLine,
1716 ContainingType, VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit,
1717 TemplateParams, Declaration, RetainedNodes, ThrownTypes);
1718
1719 EXPECT_EQ(dwarf::DW_TAG_subprogram, N->getTag());
1720 EXPECT_EQ(Scope, N->getScope());
1721 EXPECT_EQ(Name, N->getName());
1722 EXPECT_EQ(LinkageName, N->getLinkageName());
1723 EXPECT_EQ(File, N->getFile());
1724 EXPECT_EQ(Line, N->getLine());
1725 EXPECT_EQ(Type, N->getType());
1726 EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());
1727 EXPECT_EQ(IsDefinition, N->isDefinition());
1728 EXPECT_EQ(ScopeLine, N->getScopeLine());
1729 EXPECT_EQ(ContainingType, N->getContainingType());
1730 EXPECT_EQ(Virtuality, N->getVirtuality());
1731 EXPECT_EQ(VirtualIndex, N->getVirtualIndex());
1732 EXPECT_EQ(ThisAdjustment, N->getThisAdjustment());
1733 EXPECT_EQ(Flags, N->getFlags());
1734 EXPECT_EQ(IsOptimized, N->isOptimized());
1735 EXPECT_EQ(Unit, N->getUnit());
1736 EXPECT_EQ(TemplateParams, N->getTemplateParams().get());
1737 EXPECT_EQ(Declaration, N->getDeclaration());
1738 EXPECT_EQ(RetainedNodes, N->getRetainedNodes().get());
1739 EXPECT_EQ(ThrownTypes, N->getThrownTypes().get());
1740 EXPECT_EQ(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1741 Type, ScopeLine, ContainingType, VirtualIndex,
1742 ThisAdjustment, Flags, SPFlags, Unit,
1743 TemplateParams, Declaration, RetainedNodes,
1744 ThrownTypes));
1745
1746 EXPECT_NE(N, DISubprogram::get(Context, getCompositeType(), Name, LinkageName,
1747 File, Line, Type, ScopeLine, ContainingType,
1748 VirtualIndex, ThisAdjustment, Flags, SPFlags,
1749 Unit, TemplateParams, Declaration,
1750 RetainedNodes, ThrownTypes));
1751 EXPECT_NE(N, DISubprogram::get(Context, Scope, "other", LinkageName, File,
1752 Line, Type, ScopeLine, ContainingType,
1753 VirtualIndex, ThisAdjustment, Flags, SPFlags,
1754 Unit, TemplateParams, Declaration,
1755 RetainedNodes, ThrownTypes));
1756 EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, "other", File, Line,
1757 Type, ScopeLine, ContainingType, VirtualIndex,
1758 ThisAdjustment, Flags, SPFlags, Unit,
1759 TemplateParams, Declaration, RetainedNodes,
1760 ThrownTypes));
1761 EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, getFile(),
1762 Line, Type, ScopeLine, ContainingType,
1763 VirtualIndex, ThisAdjustment, Flags, SPFlags,
1764 Unit, TemplateParams, Declaration,
1765 RetainedNodes, ThrownTypes));
1766 EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File,
1767 Line + 1, Type, ScopeLine, ContainingType,
1768 VirtualIndex, ThisAdjustment, Flags, SPFlags,
1769 Unit, TemplateParams, Declaration,
1770 RetainedNodes, ThrownTypes));
1771 EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1772 getSubroutineType(), ScopeLine, ContainingType,
1773 VirtualIndex, ThisAdjustment, Flags, SPFlags,
1774 Unit, TemplateParams, Declaration,
1775 RetainedNodes, ThrownTypes));
1776 EXPECT_NE(N, DISubprogram::get(
1777 Context, Scope, Name, LinkageName, File, Line, Type,
1778 ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
1779 Flags, SPFlags ^ DISubprogram::SPFlagLocalToUnit, Unit,
1780 TemplateParams, Declaration, RetainedNodes, ThrownTypes));
1781 EXPECT_NE(N, DISubprogram::get(
1782 Context, Scope, Name, LinkageName, File, Line, Type,
1783 ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
1784 Flags, SPFlags ^ DISubprogram::SPFlagDefinition, Unit,
1785 TemplateParams, Declaration, RetainedNodes, ThrownTypes));
1786 EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1787 Type, ScopeLine + 1, ContainingType,
1788 VirtualIndex, ThisAdjustment, Flags, SPFlags,
1789 Unit, TemplateParams, Declaration,
1790 RetainedNodes, ThrownTypes));
1791 EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1792 Type, ScopeLine, getCompositeType(),
1793 VirtualIndex, ThisAdjustment, Flags, SPFlags,
1794 Unit, TemplateParams, Declaration,
1795 RetainedNodes, ThrownTypes));
1796 EXPECT_NE(N, DISubprogram::get(
1797 Context, Scope, Name, LinkageName, File, Line, Type,
1798 ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
1799 Flags, SPFlags ^ DISubprogram::SPFlagVirtual, Unit,
1800 TemplateParams, Declaration, RetainedNodes, ThrownTypes));
1801 EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1802 Type, ScopeLine, ContainingType,
1803 VirtualIndex + 1, ThisAdjustment, Flags,
1804 SPFlags, Unit, TemplateParams, Declaration,
1805 RetainedNodes, ThrownTypes));
1806 EXPECT_NE(N, DISubprogram::get(
1807 Context, Scope, Name, LinkageName, File, Line, Type,
1808 ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
1809 Flags, SPFlags ^ DISubprogram::SPFlagOptimized, Unit,
1810 TemplateParams, Declaration, RetainedNodes, ThrownTypes));
1811 EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1812 Type, ScopeLine, ContainingType, VirtualIndex,
1813 ThisAdjustment, Flags, SPFlags, nullptr,
1814 TemplateParams, Declaration, RetainedNodes,
1815 ThrownTypes));
1816 EXPECT_NE(N,
1817 DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1818 Type, ScopeLine, ContainingType, VirtualIndex,
1819 ThisAdjustment, Flags, SPFlags, Unit, getTuple(),
1820 Declaration, RetainedNodes, ThrownTypes));
1821 EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1822 Type, ScopeLine, ContainingType, VirtualIndex,
1823 ThisAdjustment, Flags, SPFlags, Unit,
1824 TemplateParams, getSubprogram(), RetainedNodes,
1825 ThrownTypes));
1826 EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1827 Type, ScopeLine, ContainingType, VirtualIndex,
1828 ThisAdjustment, Flags, SPFlags, Unit,
1829 TemplateParams, Declaration, getTuple()));
1830 EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1831 Type, ScopeLine, ContainingType, VirtualIndex,
1832 ThisAdjustment, Flags, SPFlags, Unit,
1833 TemplateParams, Declaration, RetainedNodes,
1834 getTuple()));
1835
1836 TempDISubprogram Temp = N->clone();
1837 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1838 }
1839
1840 typedef MetadataTest DILexicalBlockTest;
1841
1842 TEST_F(DILexicalBlockTest, get) {
1843 DILocalScope *Scope = getSubprogram();
1844 DIFile *File = getFile();
1845 unsigned Line = 5;
1846 unsigned Column = 8;
1847
1848 auto *N = DILexicalBlock::get(Context, Scope, File, Line, Column);
1849
1850 EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());
1851 EXPECT_EQ(Scope, N->getScope());
1852 EXPECT_EQ(File, N->getFile());
1853 EXPECT_EQ(Line, N->getLine());
1854 EXPECT_EQ(Column, N->getColumn());
1855 EXPECT_EQ(N, DILexicalBlock::get(Context, Scope, File, Line, Column));
1856
1857 EXPECT_NE(N,
1858 DILexicalBlock::get(Context, getSubprogram(), File, Line, Column));
1859 EXPECT_NE(N, DILexicalBlock::get(Context, Scope, getFile(), Line, Column));
1860 EXPECT_NE(N, DILexicalBlock::get(Context, Scope, File, Line + 1, Column));
1861 EXPECT_NE(N, DILexicalBlock::get(Context, Scope, File, Line, Column + 1));
1862
1863 TempDILexicalBlock Temp = N->clone();
1864 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1865 }
1866
1867 TEST_F(DILexicalBlockTest, Overflow) {
1868 DISubprogram *SP = getSubprogram();
1869 DIFile *F = getFile();
1870 {
1871 auto *LB = DILexicalBlock::get(Context, SP, F, 2, 7);
1872 EXPECT_EQ(2u, LB->getLine());
1873 EXPECT_EQ(7u, LB->getColumn());
1874 }
1875 unsigned U16 = 1u << 16;
1876 {
1877 auto *LB = DILexicalBlock::get(Context, SP, F, UINT32_MAX, U16 - 1);
1878 EXPECT_EQ(UINT32_MAX, LB->getLine());
1879 EXPECT_EQ(U16 - 1, LB->getColumn());
1880 }
1881 {
1882 auto *LB = DILexicalBlock::get(Context, SP, F, UINT32_MAX, U16);
1883 EXPECT_EQ(UINT32_MAX, LB->getLine());
1884 EXPECT_EQ(0u, LB->getColumn());
1885 }
1886 {
1887 auto *LB = DILexicalBlock::get(Context, SP, F, UINT32_MAX, U16 + 1);
1888 EXPECT_EQ(UINT32_MAX, LB->getLine());
1889 EXPECT_EQ(0u, LB->getColumn());
1890 }
1891 }
1892
1893 typedef MetadataTest DILexicalBlockFileTest;
1894
1895 TEST_F(DILexicalBlockFileTest, get) {
1896 DILocalScope *Scope = getSubprogram();
1897 DIFile *File = getFile();
1898 unsigned Discriminator = 5;
1899
1900 auto *N = DILexicalBlockFile::get(Context, Scope, File, Discriminator);
1901
1902 EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());
1903 EXPECT_EQ(Scope, N->getScope());
1904 EXPECT_EQ(File, N->getFile());
1905 EXPECT_EQ(Discriminator, N->getDiscriminator());
1906 EXPECT_EQ(N, DILexicalBlockFile::get(Context, Scope, File, Discriminator));
1907
1908 EXPECT_NE(N, DILexicalBlockFile::get(Context, getSubprogram(), File,
1909 Discriminator));
1910 EXPECT_NE(N,
1911 DILexicalBlockFile::get(Context, Scope, getFile(), Discriminator));
1912 EXPECT_NE(N,
1913 DILexicalBlockFile::get(Context, Scope, File, Discriminator + 1));
1914
1915 TempDILexicalBlockFile Temp = N->clone();
1916 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1917 }
1918
1919 typedef MetadataTest DINamespaceTest;
1920
1921 TEST_F(DINamespaceTest, get) {
1922 DIScope *Scope = getFile();
1923 StringRef Name = "namespace";
1924 bool ExportSymbols = true;
1925
1926 auto *N = DINamespace::get(Context, Scope, Name, ExportSymbols);
1927
1928 EXPECT_EQ(dwarf::DW_TAG_namespace, N->getTag());
1929 EXPECT_EQ(Scope, N->getScope());
1930 EXPECT_EQ(Name, N->getName());
1931 EXPECT_EQ(N, DINamespace::get(Context, Scope, Name, ExportSymbols));
1932 EXPECT_NE(N, DINamespace::get(Context, getFile(), Name, ExportSymbols));
1933 EXPECT_NE(N, DINamespace::get(Context, Scope, "other", ExportSymbols));
1934 EXPECT_NE(N, DINamespace::get(Context, Scope, Name, !ExportSymbols));
1935
1936 TempDINamespace Temp = N->clone();
1937 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1938 }
1939
1940 typedef MetadataTest DIModuleTest;
1941
1942 TEST_F(DIModuleTest, get) {
1943 DIScope *Scope = getFile();
1944 StringRef Name = "module";
1945 StringRef ConfigMacro = "-DNDEBUG";
1946 StringRef Includes = "-I.";
1947 StringRef Sysroot = "/";
1948
1949 auto *N = DIModule::get(Context, Scope, Name, ConfigMacro, Includes, Sysroot);
1950
1951 EXPECT_EQ(dwarf::DW_TAG_module, N->getTag());
1952 EXPECT_EQ(Scope, N->getScope());
1953 EXPECT_EQ(Name, N->getName());
1954 EXPECT_EQ(ConfigMacro, N->getConfigurationMacros());
1955 EXPECT_EQ(Includes, N->getIncludePath());
1956 EXPECT_EQ(Sysroot, N->getISysRoot());
1957 EXPECT_EQ(N, DIModule::get(Context, Scope, Name,
1958 ConfigMacro, Includes, Sysroot));
1959 EXPECT_NE(N, DIModule::get(Context, getFile(), Name,
1960 ConfigMacro, Includes, Sysroot));
1961 EXPECT_NE(N, DIModule::get(Context, Scope, "other",
1962 ConfigMacro, Includes, Sysroot));
1963 EXPECT_NE(N, DIModule::get(Context, Scope, Name,
1964 "other", Includes, Sysroot));
1965 EXPECT_NE(N, DIModule::get(Context, Scope, Name,
1966 ConfigMacro, "other", Sysroot));
1967 EXPECT_NE(N, DIModule::get(Context, Scope, Name,
1968 ConfigMacro, Includes, "other"));
1969
1970 TempDIModule Temp = N->clone();
1971 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1972 }
1973
1974 typedef MetadataTest DITemplateTypeParameterTest;
1975
1976 TEST_F(DITemplateTypeParameterTest, get) {
1977 StringRef Name = "template";
1978 DIType *Type = getBasicType("basic");
1979
1980 auto *N = DITemplateTypeParameter::get(Context, Name, Type);
1981
1982 EXPECT_EQ(dwarf::DW_TAG_template_type_parameter, N->getTag());
1983 EXPECT_EQ(Name, N->getName());
1984 EXPECT_EQ(Type, N->getType());
1985 EXPECT_EQ(N, DITemplateTypeParameter::get(Context, Name, Type));
1986
1987 EXPECT_NE(N, DITemplateTypeParameter::get(Context, "other", Type));
1988 EXPECT_NE(N,
1989 DITemplateTypeParameter::get(Context, Name, getBasicType("other")));
1990
1991 TempDITemplateTypeParameter Temp = N->clone();
1992 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1993 }
1994
1995 typedef MetadataTest DITemplateValueParameterTest;
1996
1997 TEST_F(DITemplateValueParameterTest, get) {
1998 unsigned Tag = dwarf::DW_TAG_template_value_parameter;
1999 StringRef Name = "template";
2000 DIType *Type = getBasicType("basic");
2001 Metadata *Value = getConstantAsMetadata();
2002
2003 auto *N = DITemplateValueParameter::get(Context, Tag, Name, Type, Value);
2004 EXPECT_EQ(Tag, N->getTag());
2005 EXPECT_EQ(Name, N->getName());
2006 EXPECT_EQ(Type, N->getType());
2007 EXPECT_EQ(Value, N->getValue());
2008 EXPECT_EQ(N, DITemplateValueParameter::get(Context, Tag, Name, Type, Value));
2009
2010 EXPECT_NE(N, DITemplateValueParameter::get(
2011 Context, dwarf::DW_TAG_GNU_template_template_param, Name,
2012 Type, Value));
2013 EXPECT_NE(N,
2014 DITemplateValueParameter::get(Context, Tag, "other", Type, Value));
2015 EXPECT_NE(N, DITemplateValueParameter::get(Context, Tag, Name,
2016 getBasicType("other"), Value));
2017 EXPECT_NE(N, DITemplateValueParameter::get(Context, Tag, Name, Type,
2018 getConstantAsMetadata()));
2019
2020 TempDITemplateValueParameter Temp = N->clone();
2021 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2022 }
2023
2024 typedef MetadataTest DIGlobalVariableTest;
2025
2026 TEST_F(DIGlobalVariableTest, get) {
2027 DIScope *Scope = getSubprogram();
2028 StringRef Name = "name";
2029 StringRef LinkageName = "linkage";
2030 DIFile *File = getFile();
2031 unsigned Line = 5;
2032 DIType *Type = getDerivedType();
2033 bool IsLocalToUnit = false;
2034 bool IsDefinition = true;
2035 MDTuple *templateParams = getTuple();
2036 DIDerivedType *StaticDataMemberDeclaration =
2037 cast<DIDerivedType>(getDerivedType());
2038
2039 uint32_t AlignInBits = 8;
2040
2041 auto *N = DIGlobalVariable::get(
2042 Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
2043 IsDefinition, StaticDataMemberDeclaration, templateParams, AlignInBits);
2044
2045 EXPECT_EQ(dwarf::DW_TAG_variable, N->getTag());
2046 EXPECT_EQ(Scope, N->getScope());
2047 EXPECT_EQ(Name, N->getName());
2048 EXPECT_EQ(LinkageName, N->getLinkageName());
2049 EXPECT_EQ(File, N->getFile());
2050 EXPECT_EQ(Line, N->getLine());
2051 EXPECT_EQ(Type, N->getType());
2052 EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());
2053 EXPECT_EQ(IsDefinition, N->isDefinition());
2054 EXPECT_EQ(StaticDataMemberDeclaration, N->getStaticDataMemberDeclaration());
2055 EXPECT_EQ(templateParams, N->getTemplateParams());
2056 EXPECT_EQ(AlignInBits, N->getAlignInBits());
2057 EXPECT_EQ(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
2058 Line, Type, IsLocalToUnit, IsDefinition,
2059 StaticDataMemberDeclaration,
2060 templateParams, AlignInBits));
2061
2062 EXPECT_NE(N, DIGlobalVariable::get(
2063 Context, getSubprogram(), Name, LinkageName, File, Line,
2064 Type, IsLocalToUnit, IsDefinition,
2065 StaticDataMemberDeclaration, templateParams, AlignInBits));
2066 EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, "other", LinkageName, File,
2067 Line, Type, IsLocalToUnit, IsDefinition,
2068 StaticDataMemberDeclaration,
2069 templateParams, AlignInBits));
2070 EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, "other", File, Line,
2071 Type, IsLocalToUnit, IsDefinition,
2072 StaticDataMemberDeclaration,
2073 templateParams, AlignInBits));
2074 EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName,
2075 getFile(), Line, Type, IsLocalToUnit,
2076 IsDefinition, StaticDataMemberDeclaration,
2077 templateParams, AlignInBits));
2078 EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
2079 Line + 1, Type, IsLocalToUnit,
2080 IsDefinition, StaticDataMemberDeclaration,
2081 templateParams, AlignInBits));
2082 EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
2083 Line, getDerivedType(), IsLocalToUnit,
2084 IsDefinition, StaticDataMemberDeclaration,
2085 templateParams, AlignInBits));
2086 EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
2087 Line, Type, !IsLocalToUnit, IsDefinition,
2088 StaticDataMemberDeclaration,
2089 templateParams, AlignInBits));
2090 EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
2091 Line, Type, IsLocalToUnit, !IsDefinition,
2092 StaticDataMemberDeclaration,
2093 templateParams, AlignInBits));
2094 EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
2095 Line, Type, IsLocalToUnit, IsDefinition,
2096 cast<DIDerivedType>(getDerivedType()),
2097 templateParams, AlignInBits));
2098 EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
2099 Line, Type, IsLocalToUnit, IsDefinition,
2100 StaticDataMemberDeclaration, nullptr,
2101 AlignInBits));
2102 EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
2103 Line, Type, IsLocalToUnit, IsDefinition,
2104 StaticDataMemberDeclaration,
2105 templateParams, (AlignInBits << 1)));
2106
2107 TempDIGlobalVariable Temp = N->clone();
2108 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2109 }
2110
2111 typedef MetadataTest DIGlobalVariableExpressionTest;
2112
2113 TEST_F(DIGlobalVariableExpressionTest, get) {
2114 DIScope *Scope = getSubprogram();
2115 StringRef Name = "name";
2116 StringRef LinkageName = "linkage";
2117 DIFile *File = getFile();
2118 unsigned Line = 5;
2119 DIType *Type = getDerivedType();
2120 bool IsLocalToUnit = false;
2121 bool IsDefinition = true;
2122 MDTuple *templateParams = getTuple();
2123 auto *Expr = DIExpression::get(Context, {1, 2});
2124 auto *Expr2 = DIExpression::get(Context, {1, 2, 3});
2125 DIDerivedType *StaticDataMemberDeclaration =
2126 cast<DIDerivedType>(getDerivedType());
2127 uint32_t AlignInBits = 8;
2128
2129 auto *Var = DIGlobalVariable::get(
2130 Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
2131 IsDefinition, StaticDataMemberDeclaration, templateParams, AlignInBits);
2132 auto *Var2 = DIGlobalVariable::get(
2133 Context, Scope, "other", LinkageName, File, Line, Type, IsLocalToUnit,
2134 IsDefinition, StaticDataMemberDeclaration, templateParams, AlignInBits);
2135 auto *N = DIGlobalVariableExpression::get(Context, Var, Expr);
2136
2137 EXPECT_EQ(Var, N->getVariable());
2138 EXPECT_EQ(Expr, N->getExpression());
2139 EXPECT_EQ(N, DIGlobalVariableExpression::get(Context, Var, Expr));
2140 EXPECT_NE(N, DIGlobalVariableExpression::get(Context, Var2, Expr));
2141 EXPECT_NE(N, DIGlobalVariableExpression::get(Context, Var, Expr2));
2142
2143 TempDIGlobalVariableExpression Temp = N->clone();
2144 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2145 }
2146
2147 typedef MetadataTest DILocalVariableTest;
2148
2149 TEST_F(DILocalVariableTest, get) {
2150 DILocalScope *Scope = getSubprogram();
2151 StringRef Name = "name";
2152 DIFile *File = getFile();
2153 unsigned Line = 5;
2154 DIType *Type = getDerivedType();
2155 unsigned Arg = 6;
2156 DINode::DIFlags Flags = static_cast<DINode::DIFlags>(7);
2157 uint32_t AlignInBits = 8;
2158
2159 auto *N =
2160 DILocalVariable::get(Context, Scope, Name, File, Line, Type, Arg, Flags,
2161 AlignInBits);
2162 EXPECT_TRUE(N->isParameter());
2163 EXPECT_EQ(Scope, N->getScope());
2164 EXPECT_EQ(Name, N->getName());
2165 EXPECT_EQ(File, N->getFile());
2166 EXPECT_EQ(Line, N->getLine());
2167 EXPECT_EQ(Type, N->getType());
2168 EXPECT_EQ(Arg, N->getArg());
2169 EXPECT_EQ(Flags, N->getFlags());
2170 EXPECT_EQ(AlignInBits, N->getAlignInBits());
2171 EXPECT_EQ(N, DILocalVariable::get(Context, Scope, Name, File, Line, Type, Arg,
2172 Flags, AlignInBits));
2173
2174 EXPECT_FALSE(
2175 DILocalVariable::get(Context, Scope, Name, File, Line, Type, 0, Flags,
2176 AlignInBits)->isParameter());
2177 EXPECT_NE(N, DILocalVariable::get(Context, getSubprogram(), Name, File, Line,
2178 Type, Arg, Flags, AlignInBits));
2179 EXPECT_NE(N, DILocalVariable::get(Context, Scope, "other", File, Line, Type,
2180 Arg, Flags, AlignInBits));
2181 EXPECT_NE(N, DILocalVariable::get(Context, Scope, Name, getFile(), Line, Type,
2182 Arg, Flags, AlignInBits));
2183 EXPECT_NE(N, DILocalVariable::get(Context, Scope, Name, File, Line + 1, Type,
2184 Arg, Flags, AlignInBits));
2185 EXPECT_NE(N, DILocalVariable::get(Context, Scope, Name, File, Line,
2186 getDerivedType(), Arg, Flags, AlignInBits));
2187 EXPECT_NE(N, DILocalVariable::get(Context, Scope, Name, File, Line, Type,
2188 Arg + 1, Flags, AlignInBits));
2189 EXPECT_NE(N, DILocalVariable::get(Context, Scope, Name, File, Line, Type,
2190 Arg, Flags, (AlignInBits << 1)));
2191
2192 TempDILocalVariable Temp = N->clone();
2193 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2194 }
2195
2196 TEST_F(DILocalVariableTest, getArg256) {
2197 EXPECT_EQ(255u, DILocalVariable::get(Context, getSubprogram(), "", getFile(),
2198 0, nullptr, 255, DINode::FlagZero, 0)
2199 ->getArg());
2200 EXPECT_EQ(256u, DILocalVariable::get(Context, getSubprogram(), "", getFile(),
2201 0, nullptr, 256, DINode::FlagZero, 0)
2202 ->getArg());
2203 EXPECT_EQ(257u, DILocalVariable::get(Context, getSubprogram(), "", getFile(),
2204 0, nullptr, 257, DINode::FlagZero, 0)
2205 ->getArg());
2206 unsigned Max = UINT16_MAX;
2207 EXPECT_EQ(Max, DILocalVariable::get(Context, getSubprogram(), "", getFile(),
2208 0, nullptr, Max, DINode::FlagZero, 0)
2209 ->getArg());
2210 }
2211
2212 typedef MetadataTest DIExpressionTest;
2213
2214 TEST_F(DIExpressionTest, get) {
2215 uint64_t Elements[] = {2, 6, 9, 78, 0};
2216 auto *N = DIExpression::get(Context, Elements);
2217 EXPECT_EQ(makeArrayRef(Elements), N->getElements());
2218 EXPECT_EQ(N, DIExpression::get(Context, Elements));
2219
2220 EXPECT_EQ(5u, N->getNumElements());
2221 EXPECT_EQ(2u, N->getElement(0));
2222 EXPECT_EQ(6u, N->getElement(1));
2223 EXPECT_EQ(9u, N->getElement(2));
2224 EXPECT_EQ(78u, N->getElement(3));
2225 EXPECT_EQ(0u, N->getElement(4));
2226
2227 TempDIExpression Temp = N->clone();
2228 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2229
2230 // Test DIExpression::prepend().
2231 uint64_t Elts0[] = {dwarf::DW_OP_LLVM_fragment, 0, 32};
2232 auto *N0 = DIExpression::get(Context, Elts0);
2233 auto *N0WithPrependedOps = DIExpression::prepend(N0, true, 64, true, true);
2234 uint64_t Elts1[] = {dwarf::DW_OP_deref,
2235 dwarf::DW_OP_plus_uconst, 64,
2236 dwarf::DW_OP_deref,
2237 dwarf::DW_OP_stack_value,
2238 dwarf::DW_OP_LLVM_fragment, 0, 32};
2239 auto *N1 = DIExpression::get(Context, Elts1);
2240 EXPECT_EQ(N0WithPrependedOps, N1);
2241
2242 // Test DIExpression::append().
2243 uint64_t Elts2[] = {dwarf::DW_OP_deref, dwarf::DW_OP_plus_uconst, 64,
2244 dwarf::DW_OP_deref, dwarf::DW_OP_stack_value};
2245 auto *N2 = DIExpression::append(N0, Elts2);
2246 EXPECT_EQ(N0WithPrependedOps, N2);
2247 }
2248
2249 TEST_F(DIExpressionTest, isValid) {
2250 #define EXPECT_VALID(...) \
2251 do { \
2252 uint64_t Elements[] = {__VA_ARGS__}; \
2253 EXPECT_TRUE(DIExpression::get(Context, Elements)->isValid()); \
2254 } while (false)
2255 #define EXPECT_INVALID(...) \
2256 do { \
2257 uint64_t Elements[] = {__VA_ARGS__}; \
2258 EXPECT_FALSE(DIExpression::get(Context, Elements)->isValid()); \
2259 } while (false)
2260
2261 // Empty expression should be valid.
2262 EXPECT_TRUE(DIExpression::get(Context, None));
2263
2264 // Valid constructions.
2265 EXPECT_VALID(dwarf::DW_OP_plus_uconst, 6);
2266 EXPECT_VALID(dwarf::DW_OP_constu, 6, dwarf::DW_OP_plus);
2267 EXPECT_VALID(dwarf::DW_OP_deref);
2268 EXPECT_VALID(dwarf::DW_OP_LLVM_fragment, 3, 7);
2269 EXPECT_VALID(dwarf::DW_OP_plus_uconst, 6, dwarf::DW_OP_deref);
2270 EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_plus_uconst, 6);
2271 EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_LLVM_fragment, 3, 7);
2272 EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_plus_uconst, 6,
2273 dwarf::DW_OP_LLVM_fragment, 3, 7);
2274
2275 // Invalid constructions.
2276 EXPECT_INVALID(~0u);
2277 EXPECT_INVALID(dwarf::DW_OP_plus, 0);
2278 EXPECT_INVALID(dwarf::DW_OP_plus_uconst);
2279 EXPECT_INVALID(dwarf::DW_OP_LLVM_fragment);
2280 EXPECT_INVALID(dwarf::DW_OP_LLVM_fragment, 3);
2281 EXPECT_INVALID(dwarf::DW_OP_LLVM_fragment, 3, 7, dwarf::DW_OP_plus_uconst, 3);
2282 EXPECT_INVALID(dwarf::DW_OP_LLVM_fragment, 3, 7, dwarf::DW_OP_deref);
2283
2284 #undef EXPECT_VALID
2285 #undef EXPECT_INVALID
2286 }
2287
2288 typedef MetadataTest DIObjCPropertyTest;
2289
2290 TEST_F(DIObjCPropertyTest, get) {
2291 StringRef Name = "name";
2292 DIFile *File = getFile();
2293 unsigned Line = 5;
2294 StringRef GetterName = "getter";
2295 StringRef SetterName = "setter";
2296 unsigned Attributes = 7;
2297 DIType *Type = getBasicType("basic");
2298
2299 auto *N = DIObjCProperty::get(Context, Name, File, Line, GetterName,
2300 SetterName, Attributes, Type);
2301
2302 EXPECT_EQ(dwarf::DW_TAG_APPLE_property, N->getTag());
2303 EXPECT_EQ(Name, N->getName());
2304 EXPECT_EQ(File, N->getFile());
2305 EXPECT_EQ(Line, N->getLine());
2306 EXPECT_EQ(GetterName, N->getGetterName());
2307 EXPECT_EQ(SetterName, N->getSetterName());
2308 EXPECT_EQ(Attributes, N->getAttributes());
2309 EXPECT_EQ(Type, N->getType());
2310 EXPECT_EQ(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,
2311 SetterName, Attributes, Type));
2312
2313 EXPECT_NE(N, DIObjCProperty::get(Context, "other", File, Line, GetterName,
2314 SetterName, Attributes, Type));
2315 EXPECT_NE(N, DIObjCProperty::get(Context, Name, getFile(), Line, GetterName,
2316 SetterName, Attributes, Type));
2317 EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line + 1, GetterName,
2318 SetterName, Attributes, Type));
2319 EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, "other",
2320 SetterName, Attributes, Type));
2321 EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,
2322 "other", Attributes, Type));
2323 EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,
2324 SetterName, Attributes + 1, Type));
2325 EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,
2326 SetterName, Attributes,
2327 getBasicType("other")));
2328
2329 TempDIObjCProperty Temp = N->clone();
2330 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2331 }
2332
2333 typedef MetadataTest DIImportedEntityTest;
2334
2335 TEST_F(DIImportedEntityTest, get) {
2336 unsigned Tag = dwarf::DW_TAG_imported_module;
2337 DIScope *Scope = getSubprogram();
2338 DINode *Entity = getCompositeType();
2339 DIFile *File = getFile();
2340 unsigned Line = 5;
2341 StringRef Name = "name";
2342
2343 auto *N =
2344 DIImportedEntity::get(Context, Tag, Scope, Entity, File, Line, Name);
2345
2346 EXPECT_EQ(Tag, N->getTag());
2347 EXPECT_EQ(Scope, N->getScope());
2348 EXPECT_EQ(Entity, N->getEntity());
2349 EXPECT_EQ(File, N->getFile());
2350 EXPECT_EQ(Line, N->getLine());
2351 EXPECT_EQ(Name, N->getName());
2352 EXPECT_EQ(
2353 N, DIImportedEntity::get(Context, Tag, Scope, Entity, File, Line, Name));
2354
2355 EXPECT_NE(N,
2356 DIImportedEntity::get(Context, dwarf::DW_TAG_imported_declaration,
2357 Scope, Entity, File, Line, Name));
2358 EXPECT_NE(N, DIImportedEntity::get(Context, Tag, getSubprogram(), Entity,
2359 File, Line, Name));
2360 EXPECT_NE(N, DIImportedEntity::get(Context, Tag, Scope, getCompositeType(),
2361 File, Line, Name));
2362 EXPECT_NE(N, DIImportedEntity::get(Context, Tag, Scope, Entity, nullptr, Line,
2363 Name));
2364 EXPECT_NE(N, DIImportedEntity::get(Context, Tag, Scope, Entity, File,
2365 Line + 1, Name));
2366 EXPECT_NE(N, DIImportedEntity::get(Context, Tag, Scope, Entity, File, Line,
2367 "other"));
2368
2369 TempDIImportedEntity Temp = N->clone();
2370 EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2371 }
2372
2373 typedef MetadataTest MetadataAsValueTest;
2374
2375 TEST_F(MetadataAsValueTest, MDNode) {
2376 MDNode *N = MDNode::get(Context, None);
2377 auto *V = MetadataAsValue::get(Context, N);
2378 EXPECT_TRUE(V->getType()->isMetadataTy());
2379 EXPECT_EQ(N, V->getMetadata());
2380
2381 auto *V2 = MetadataAsValue::get(Context, N);
2382 EXPECT_EQ(V, V2);
2383 }
2384
2385 TEST_F(MetadataAsValueTest, MDNodeMDNode) {
2386 MDNode *N = MDNode::get(Context, None);
2387 Metadata *Ops[] = {N};
2388 MDNode *N2 = MDNode::get(Context, Ops);
2389 auto *V = MetadataAsValue::get(Context, N2);
2390 EXPECT_TRUE(V->getType()->isMetadataTy());
2391 EXPECT_EQ(N2, V->getMetadata());
2392
2393 auto *V2 = MetadataAsValue::get(Context, N2);
2394 EXPECT_EQ(V, V2);
2395
2396 auto *V3 = MetadataAsValue::get(Context, N);
2397 EXPECT_TRUE(V3->getType()->isMetadataTy());
2398 EXPECT_NE(V, V3);
2399 EXPECT_EQ(N, V3->getMetadata());
2400 }
2401
2402 TEST_F(MetadataAsValueTest, MDNodeConstant) {
2403 auto *C = ConstantInt::getTrue(Context);
2404 auto *MD = ConstantAsMetadata::get(C);
2405 Metadata *Ops[] = {MD};
2406 auto *N = MDNode::get(Context, Ops);
2407
2408 auto *V = MetadataAsValue::get(Context, MD);
2409 EXPECT_TRUE(V->getType()->isMetadataTy());
2410 EXPECT_EQ(MD, V->getMetadata());
2411
2412 auto *V2 = MetadataAsValue::get(Context, N);
2413 EXPECT_EQ(MD, V2->getMetadata());
2414 EXPECT_EQ(V, V2);
2415 }
2416
2417 typedef MetadataTest ValueAsMetadataTest;
2418
2419 TEST_F(ValueAsMetadataTest, UpdatesOnRAUW) {
2420 Type *Ty = Type::getInt1PtrTy(Context);
2421 std::unique_ptr<GlobalVariable> GV0(
2422 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
2423 auto *MD = ValueAsMetadata::get(GV0.get());
2424 EXPECT_TRUE(MD->getValue() == GV0.get());
2425 ASSERT_TRUE(GV0->use_empty());
2426
2427 std::unique_ptr<GlobalVariable> GV1(
2428 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
2429 GV0->replaceAllUsesWith(GV1.get());
2430 EXPECT_TRUE(MD->getValue() == GV1.get());
2431 }
2432
2433 TEST_F(ValueAsMetadataTest, TempTempReplacement) {
2434 // Create a constant.
2435 ConstantAsMetadata *CI =
2436 ConstantAsMetadata::get(ConstantInt::get(Context, APInt(8, 0)));
2437
2438 auto Temp1 = MDTuple::getTemporary(Context, None);
2439 auto Temp2 = MDTuple::getTemporary(Context, {CI});
2440 auto *N = MDTuple::get(Context, {Temp1.get()});
2441
2442 // Test replacing a temporary node with another temporary node.
2443 Temp1->replaceAllUsesWith(Temp2.get());
2444 EXPECT_EQ(N->getOperand(0), Temp2.get());
2445
2446 // Clean up Temp2 for teardown.
2447 Temp2->replaceAllUsesWith(nullptr);
2448 }
2449
2450 TEST_F(ValueAsMetadataTest, CollidingDoubleUpdates) {
2451 // Create a constant.
2452 ConstantAsMetadata *CI =
2453 ConstantAsMetadata::get(ConstantInt::get(Context, APInt(8, 0)));
2454
2455 // Create a temporary to prevent nodes from resolving.
2456 auto Temp = MDTuple::getTemporary(Context, None);
2457
2458 // When the first operand of N1 gets reset to nullptr, it'll collide with N2.
2459 Metadata *Ops1[] = {CI, CI, Temp.get()};
2460 Metadata *Ops2[] = {nullptr, CI, Temp.get()};
2461
2462 auto *N1 = MDTuple::get(Context, Ops1);
2463 auto *N2 = MDTuple::get(Context, Ops2);
2464 ASSERT_NE(N1, N2);
2465
2466 // Tell metadata that the constant is getting deleted.
2467 //
2468 // After this, N1 will be invalid, so don't touch it.
2469 ValueAsMetadata::handleDeletion(CI->getValue());
2470 EXPECT_EQ(nullptr, N2->getOperand(0));
2471 EXPECT_EQ(nullptr, N2->getOperand(1));
2472 EXPECT_EQ(Temp.get(), N2->getOperand(2));
2473
2474 // Clean up Temp for teardown.
2475 Temp->replaceAllUsesWith(nullptr);
2476 }
2477
2478 typedef MetadataTest TrackingMDRefTest;
2479
2480 TEST_F(TrackingMDRefTest, UpdatesOnRAUW) {
2481 Type *Ty = Type::getInt1PtrTy(Context);
2482 std::unique_ptr<GlobalVariable> GV0(
2483 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
2484 TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV0.get()));
2485 EXPECT_TRUE(MD->getValue() == GV0.get());
2486 ASSERT_TRUE(GV0->use_empty());
2487
2488 std::unique_ptr<GlobalVariable> GV1(
2489 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
2490 GV0->replaceAllUsesWith(GV1.get());
2491 EXPECT_TRUE(MD->getValue() == GV1.get());
2492
2493 // Reset it, so we don't inadvertently test deletion.
2494 MD.reset();
2495 }
2496
2497 TEST_F(TrackingMDRefTest, UpdatesOnDeletion) {
2498 Type *Ty = Type::getInt1PtrTy(Context);
2499 std::unique_ptr<GlobalVariable> GV(
2500 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
2501 TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV.get()));
2502 EXPECT_TRUE(MD->getValue() == GV.get());
2503 ASSERT_TRUE(GV->use_empty());
2504
2505 GV.reset();
2506 EXPECT_TRUE(!MD);
2507 }
2508
2509 TEST(NamedMDNodeTest, Search) {
2510 LLVMContext Context;
2511 ConstantAsMetadata *C =
2512 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 1));
2513 ConstantAsMetadata *C2 =
2514 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 2));
2515
2516 Metadata *const V = C;
2517 Metadata *const V2 = C2;
2518 MDNode *n = MDNode::get(Context, V);
2519 MDNode *n2 = MDNode::get(Context, V2);
2520
2521 Module M("MyModule", Context);
2522 const char *Name = "llvm.NMD1";
2523 NamedMDNode *NMD = M.getOrInsertNamedMetadata(Name);
2524 NMD->addOperand(n);
2525 NMD->addOperand(n2);
2526
2527 std::string Str;
2528 raw_string_ostream oss(Str);
2529 NMD->print(oss);
2530 EXPECT_STREQ("!llvm.NMD1 = !{!0, !1}\n",
2531 oss.str().c_str());
2532 }
2533
2534 typedef MetadataTest FunctionAttachmentTest;
2535 TEST_F(FunctionAttachmentTest, setMetadata) {
2536 Function *F = getFunction("foo");
2537 ASSERT_FALSE(F->hasMetadata());
2538 EXPECT_EQ(nullptr, F->getMetadata(LLVMContext::MD_dbg));
2539 EXPECT_EQ(nullptr, F->getMetadata("dbg"));
2540 EXPECT_EQ(nullptr, F->getMetadata("other"));
2541
2542 DISubprogram *SP1 = getSubprogram();
2543 DISubprogram *SP2 = getSubprogram();
2544 ASSERT_NE(SP1, SP2);
2545
2546 F->setMetadata("dbg", SP1);
2547 EXPECT_TRUE(F->hasMetadata());
2548 EXPECT_EQ(SP1, F->getMetadata(LLVMContext::MD_dbg));
2549 EXPECT_EQ(SP1, F->getMetadata("dbg"));
2550 EXPECT_EQ(nullptr, F->getMetadata("other"));
2551
2552 F->setMetadata(LLVMContext::MD_dbg, SP2);
2553 EXPECT_TRUE(F->hasMetadata());
2554 EXPECT_EQ(SP2, F->getMetadata(LLVMContext::MD_dbg));
2555 EXPECT_EQ(SP2, F->getMetadata("dbg"));
2556 EXPECT_EQ(nullptr, F->getMetadata("other"));
2557
2558 F->setMetadata("dbg", nullptr);
2559 EXPECT_FALSE(F->hasMetadata());
2560 EXPECT_EQ(nullptr, F->getMetadata(LLVMContext::MD_dbg));
2561 EXPECT_EQ(nullptr, F->getMetadata("dbg"));
2562 EXPECT_EQ(nullptr, F->getMetadata("other"));
2563
2564 MDTuple *T1 = getTuple();
2565 MDTuple *T2 = getTuple();
2566 ASSERT_NE(T1, T2);
2567
2568 F->setMetadata("other1", T1);
2569 F->setMetadata("other2", T2);
2570 EXPECT_TRUE(F->hasMetadata());
2571 EXPECT_EQ(T1, F->getMetadata("other1"));
2572 EXPECT_EQ(T2, F->getMetadata("other2"));
2573 EXPECT_EQ(nullptr, F->getMetadata("dbg"));
2574
2575 F->setMetadata("other1", T2);
2576 F->setMetadata("other2", T1);
2577 EXPECT_EQ(T2, F->getMetadata("other1"));
2578 EXPECT_EQ(T1, F->getMetadata("other2"));
2579
2580 F->setMetadata("other1", nullptr);
2581 F->setMetadata("other2", nullptr);
2582 EXPECT_FALSE(F->hasMetadata());
2583 EXPECT_EQ(nullptr, F->getMetadata("other1"));
2584 EXPECT_EQ(nullptr, F->getMetadata("other2"));
2585 }
2586
2587 TEST_F(FunctionAttachmentTest, getAll) {
2588 Function *F = getFunction("foo");
2589
2590 MDTuple *T1 = getTuple();
2591 MDTuple *T2 = getTuple();
2592 MDTuple *P = getTuple();
2593 DISubprogram *SP = getSubprogram();
2594
2595 F->setMetadata("other1", T2);
2596 F->setMetadata(LLVMContext::MD_dbg, SP);
2597 F->setMetadata("other2", T1);
2598 F->setMetadata(LLVMContext::MD_prof, P);
2599 F->setMetadata("other2", T2);
2600 F->setMetadata("other1", T1);
2601
2602 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
2603 F->getAllMetadata(MDs);
2604 ASSERT_EQ(4u, MDs.size());
2605 EXPECT_EQ(LLVMContext::MD_dbg, MDs[0].first);
2606 EXPECT_EQ(LLVMContext::MD_prof, MDs[1].first);
2607 EXPECT_EQ(Context.getMDKindID("other1"), MDs[2].first);
2608 EXPECT_EQ(Context.getMDKindID("other2"), MDs[3].first);
2609 EXPECT_EQ(SP, MDs[0].second);
2610 EXPECT_EQ(P, MDs[1].second);
2611 EXPECT_EQ(T1, MDs[2].second);
2612 EXPECT_EQ(T2, MDs[3].second);
2613 }
2614
2615 TEST_F(FunctionAttachmentTest, Verifier) {
2616 Function *F = getFunction("foo");
2617 F->setMetadata("attach", getTuple());
2618 F->setIsMaterializable(true);
2619
2620 // Confirm this is materializable.
2621 ASSERT_TRUE(F->isMaterializable());
2622
2623 // Materializable functions cannot have metadata attachments.
2624 EXPECT_TRUE(verifyFunction(*F));
2625
2626 // Function declarations can.
2627 F->setIsMaterializable(false);
2628 EXPECT_FALSE(verifyModule(*F->getParent()));
2629 EXPECT_FALSE(verifyFunction(*F));
2630
2631 // So can definitions.
2632 (void)new UnreachableInst(Context, BasicBlock::Create(Context, "bb", F));
2633 EXPECT_FALSE(verifyModule(*F->getParent()));
2634 EXPECT_FALSE(verifyFunction(*F));
2635 }
2636
2637 TEST_F(FunctionAttachmentTest, EntryCount) {
2638 Function *F = getFunction("foo");
2639 EXPECT_FALSE(F->getEntryCount().hasValue());
2640 F->setEntryCount(12304, Function::PCT_Real);
2641 auto Count = F->getEntryCount();
2642 EXPECT_TRUE(Count.hasValue());
2643 EXPECT_EQ(12304u, Count.getCount());
2644 EXPECT_EQ(Function::PCT_Real, Count.getType());
2645
2646 // Repeat the same for synthetic counts.
2647 F = getFunction("bar");
2648 EXPECT_FALSE(F->getEntryCount().hasValue());
2649 F->setEntryCount(123, Function::PCT_Synthetic);
2650 Count = F->getEntryCount();
2651 EXPECT_TRUE(Count.hasValue());
2652 EXPECT_EQ(123u, Count.getCount());
2653 EXPECT_EQ(Function::PCT_Synthetic, Count.getType());
2654 }
2655
2656 TEST_F(FunctionAttachmentTest, SubprogramAttachment) {
2657 Function *F = getFunction("foo");
2658 DISubprogram *SP = getSubprogram();
2659 F->setSubprogram(SP);
2660
2661 // Note that the static_cast confirms that F->getSubprogram() actually
2662 // returns an DISubprogram.
2663 EXPECT_EQ(SP, static_cast<DISubprogram *>(F->getSubprogram()));
2664 EXPECT_EQ(SP, F->getMetadata("dbg"));
2665 EXPECT_EQ(SP, F->getMetadata(LLVMContext::MD_dbg));
2666 }
2667
2668 typedef MetadataTest DistinctMDOperandPlaceholderTest;
2669 TEST_F(DistinctMDOperandPlaceholderTest, getID) {
2670 EXPECT_EQ(7u, DistinctMDOperandPlaceholder(7).getID());
2671 }
2672
2673 TEST_F(DistinctMDOperandPlaceholderTest, replaceUseWith) {
2674 // Set up some placeholders.
2675 DistinctMDOperandPlaceholder PH0(7);
2676 DistinctMDOperandPlaceholder PH1(3);
2677 DistinctMDOperandPlaceholder PH2(0);
2678 Metadata *Ops[] = {&PH0, &PH1, &PH2};
2679 auto *D = MDTuple::getDistinct(Context, Ops);
2680 ASSERT_EQ(&PH0, D->getOperand(0));
2681 ASSERT_EQ(&PH1, D->getOperand(1));
2682 ASSERT_EQ(&PH2, D->getOperand(2));
2683
2684 // Replace them.
2685 auto *N0 = MDTuple::get(Context, None);
2686 auto *N1 = MDTuple::get(Context, N0);
2687 PH0.replaceUseWith(N0);
2688 PH1.replaceUseWith(N1);
2689 PH2.replaceUseWith(nullptr);
2690 EXPECT_EQ(N0, D->getOperand(0));
2691 EXPECT_EQ(N1, D->getOperand(1));
2692 EXPECT_EQ(nullptr, D->getOperand(2));
2693 }
2694
2695 TEST_F(DistinctMDOperandPlaceholderTest, replaceUseWithNoUser) {
2696 // There is no user, but we can still call replace.
2697 DistinctMDOperandPlaceholder(7).replaceUseWith(MDTuple::get(Context, None));
2698 }
2699
2700 // Test various assertions in metadata tracking. Don't run these tests if gtest
2701 // will use SEH to recover from them. Two of these tests get halfway through
2702 // inserting metadata into DenseMaps for tracking purposes, and then they
2703 // assert, and we attempt to destroy an LLVMContext with broken invariants,
2704 // leading to infinite loops.
2705 #if defined(GTEST_HAS_DEATH_TEST) && !defined(NDEBUG) && !defined(GTEST_HAS_SEH)
2706 TEST_F(DistinctMDOperandPlaceholderTest, MetadataAsValue) {
2707 // This shouldn't crash.
2708 DistinctMDOperandPlaceholder PH(7);
2709 EXPECT_DEATH(MetadataAsValue::get(Context, &PH),
2710 "Unexpected callback to owner");
2711 }
2712
2713 TEST_F(DistinctMDOperandPlaceholderTest, UniquedMDNode) {
2714 // This shouldn't crash.
2715 DistinctMDOperandPlaceholder PH(7);
2716 EXPECT_DEATH(MDTuple::get(Context, &PH), "Unexpected callback to owner");
2717 }
2718
2719 TEST_F(DistinctMDOperandPlaceholderTest, SecondDistinctMDNode) {
2720 // This shouldn't crash.
2721 DistinctMDOperandPlaceholder PH(7);
2722 MDTuple::getDistinct(Context, &PH);
2723 EXPECT_DEATH(MDTuple::getDistinct(Context, &PH),
2724 "Placeholders can only be used once");
2725 }
2726
2727 TEST_F(DistinctMDOperandPlaceholderTest, TrackingMDRefAndDistinctMDNode) {
2728 // TrackingMDRef doesn't install an owner callback, so it can't be detected
2729 // as an invalid use. However, using a placeholder in a TrackingMDRef *and*
2730 // a distinct node isn't possible and we should assert.
2731 //
2732 // (There's no positive test for using TrackingMDRef because it's not a
2733 // useful thing to do.)
2734 {
2735 DistinctMDOperandPlaceholder PH(7);
2736 MDTuple::getDistinct(Context, &PH);
2737 EXPECT_DEATH(TrackingMDRef Ref(&PH), "Placeholders can only be used once");
2738 }
2739 {
2740 DistinctMDOperandPlaceholder PH(7);
2741 TrackingMDRef Ref(&PH);
2742 EXPECT_DEATH(MDTuple::getDistinct(Context, &PH),
2743 "Placeholders can only be used once");
2744 }
2745 }
2746 #endif
2747
2748 } // end namespace
The LLVM Project is a collection of modular and reusable compiler and toolchain technologies.