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