unittests/IR/MetadataTest.cpp

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