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   auto *N = DICompileUnit::get(
1298       Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1299       RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1300       RetainedTypes, Subprograms, GlobalVariables, ImportedEntities);
1301
1302   EXPECT_EQ(dwarf::DW_TAG_compile_unit, N->getTag());
1303   EXPECT_EQ(SourceLanguage, N->getSourceLanguage());
1304   EXPECT_EQ(File, N->getFile());
1305   EXPECT_EQ(Producer, N->getProducer());
1306   EXPECT_EQ(IsOptimized, N->isOptimized());
1307   EXPECT_EQ(Flags, N->getFlags());
1308   EXPECT_EQ(RuntimeVersion, N->getRuntimeVersion());
1309   EXPECT_EQ(SplitDebugFilename, N->getSplitDebugFilename());
1310   EXPECT_EQ(EmissionKind, N->getEmissionKind());
1311   EXPECT_EQ(EnumTypes, N->getEnumTypes().get());
1312   EXPECT_EQ(RetainedTypes, N->getRetainedTypes().get());
1313   EXPECT_EQ(Subprograms, N->getSubprograms().get());
1314   EXPECT_EQ(GlobalVariables, N->getGlobalVariables().get());
1315   EXPECT_EQ(ImportedEntities, N->getImportedEntities().get());
1316   EXPECT_EQ(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,
1317                                   IsOptimized, Flags, RuntimeVersion,
1318                                   SplitDebugFilename, EmissionKind, EnumTypes,
1319                                   RetainedTypes, Subprograms, GlobalVariables,
1320                                   ImportedEntities));
1321
1322   EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage + 1, File, Producer,
1323                                   IsOptimized, Flags, RuntimeVersion,
1324                                   SplitDebugFilename, EmissionKind, EnumTypes,
1325                                   RetainedTypes, Subprograms, GlobalVariables,
1326                                   ImportedEntities));
1327   EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, getFile(), Producer,
1328                                   IsOptimized, Flags, RuntimeVersion,
1329                                   SplitDebugFilename, EmissionKind, EnumTypes,
1330                                   RetainedTypes, Subprograms, GlobalVariables,
1331                                   ImportedEntities));
1332   EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, "other",
1333                                   IsOptimized, Flags, RuntimeVersion,
1334                                   SplitDebugFilename, EmissionKind, EnumTypes,
1335                                   RetainedTypes, Subprograms, GlobalVariables,
1336                                   ImportedEntities));
1337   EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,
1338                                   !IsOptimized, Flags, RuntimeVersion,
1339                                   SplitDebugFilename, EmissionKind, EnumTypes,
1340                                   RetainedTypes, Subprograms, GlobalVariables,
1341                                   ImportedEntities));
1342   EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,
1343                                   IsOptimized, "other", RuntimeVersion,
1344                                   SplitDebugFilename, EmissionKind, EnumTypes,
1345                                   RetainedTypes, Subprograms, GlobalVariables,
1346                                   ImportedEntities));
1347   EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,
1348                                   IsOptimized, Flags, RuntimeVersion + 1,
1349                                   SplitDebugFilename, EmissionKind, EnumTypes,
1350                                   RetainedTypes, Subprograms, GlobalVariables,
1351                                   ImportedEntities));
1352   EXPECT_NE(N,
1353             DICompileUnit::get(Context, SourceLanguage, File, Producer,
1354                                IsOptimized, Flags, RuntimeVersion, "other",
1355                                EmissionKind, EnumTypes, RetainedTypes,
1356                                Subprograms, GlobalVariables, ImportedEntities));
1357   EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,
1358                                   IsOptimized, Flags, RuntimeVersion,
1359                                   SplitDebugFilename, EmissionKind + 1,
1360                                   EnumTypes, RetainedTypes, Subprograms,
1361                                   GlobalVariables, ImportedEntities));
1362   EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,
1363                                   IsOptimized, Flags, RuntimeVersion,
1364                                   SplitDebugFilename, EmissionKind, getTuple(),
1365                                   RetainedTypes, Subprograms, GlobalVariables,
1366                                   ImportedEntities));
1367   EXPECT_NE(N, DICompileUnit::get(
1368                    Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1369                    RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1370                    getTuple(), Subprograms, GlobalVariables, ImportedEntities));
1371   EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,
1372                                   IsOptimized, Flags, RuntimeVersion,
1373                                   SplitDebugFilename, EmissionKind, EnumTypes,
1374                                   RetainedTypes, getTuple(), GlobalVariables,
1375                                   ImportedEntities));
1376   EXPECT_NE(N, DICompileUnit::get(
1377                    Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1378                    RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1379                    RetainedTypes, Subprograms, getTuple(), ImportedEntities));
1380   EXPECT_NE(N, DICompileUnit::get(
1381                    Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1382                    RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1383                    RetainedTypes, Subprograms, GlobalVariables, getTuple()));
1384
1385   TempDICompileUnit Temp = N->clone();
1386   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1387 }
1388
1389 TEST_F(DICompileUnitTest, replaceArrays) {
1390   unsigned SourceLanguage = 1;
1391   DIFile *File = getFile();
1392   StringRef Producer = "some producer";
1393   bool IsOptimized = false;
1394   StringRef Flags = "flag after flag";
1395   unsigned RuntimeVersion = 2;
1396   StringRef SplitDebugFilename = "another/file";
1397   unsigned EmissionKind = 3;
1398   MDTuple *EnumTypes = MDTuple::getDistinct(Context, None);
1399   MDTuple *RetainedTypes = MDTuple::getDistinct(Context, None);
1400   MDTuple *ImportedEntities = MDTuple::getDistinct(Context, None);
1401   auto *N = DICompileUnit::get(
1402       Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1403       RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1404       RetainedTypes, nullptr, nullptr, ImportedEntities);
1405
1406   auto *Subprograms = MDTuple::getDistinct(Context, None);
1407   EXPECT_EQ(nullptr, N->getSubprograms().get());
1408   N->replaceSubprograms(Subprograms);
1409   EXPECT_EQ(Subprograms, N->getSubprograms().get());
1410   N->replaceSubprograms(nullptr);
1411   EXPECT_EQ(nullptr, N->getSubprograms().get());
1412
1413   auto *GlobalVariables = MDTuple::getDistinct(Context, None);
1414   EXPECT_EQ(nullptr, N->getGlobalVariables().get());
1415   N->replaceGlobalVariables(GlobalVariables);
1416   EXPECT_EQ(GlobalVariables, N->getGlobalVariables().get());
1417   N->replaceGlobalVariables(nullptr);
1418   EXPECT_EQ(nullptr, N->getGlobalVariables().get());
1419 }
1420
1421 typedef MetadataTest DISubprogramTest;
1422
1423 TEST_F(DISubprogramTest, get) {
1424   DIScopeRef Scope = getCompositeType();
1425   StringRef Name = "name";
1426   StringRef LinkageName = "linkage";
1427   DIFile *File = getFile();
1428   unsigned Line = 2;
1429   DISubroutineType *Type = getSubroutineType();
1430   bool IsLocalToUnit = false;
1431   bool IsDefinition = true;
1432   unsigned ScopeLine = 3;
1433   DITypeRef ContainingType = getCompositeType();
1434   unsigned Virtuality = 4;
1435   unsigned VirtualIndex = 5;
1436   unsigned Flags = 6;
1437   bool IsOptimized = false;
1438   llvm::Function *Function = getFunction("foo");
1439   MDTuple *TemplateParams = getTuple();
1440   DISubprogram *Declaration = getSubprogram();
1441   MDTuple *Variables = getTuple();
1442
1443   auto *N = DISubprogram::get(
1444       Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1445       IsDefinition, ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags,
1446       IsOptimized, Function, TemplateParams, Declaration, Variables);
1447
1448   EXPECT_EQ(dwarf::DW_TAG_subprogram, N->getTag());
1449   EXPECT_EQ(Scope, N->getScope());
1450   EXPECT_EQ(Name, N->getName());
1451   EXPECT_EQ(LinkageName, N->getLinkageName());
1452   EXPECT_EQ(File, N->getFile());
1453   EXPECT_EQ(Line, N->getLine());
1454   EXPECT_EQ(Type, N->getType());
1455   EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());
1456   EXPECT_EQ(IsDefinition, N->isDefinition());
1457   EXPECT_EQ(ScopeLine, N->getScopeLine());
1458   EXPECT_EQ(ContainingType, N->getContainingType());
1459   EXPECT_EQ(Virtuality, N->getVirtuality());
1460   EXPECT_EQ(VirtualIndex, N->getVirtualIndex());
1461   EXPECT_EQ(Flags, N->getFlags());
1462   EXPECT_EQ(IsOptimized, N->isOptimized());
1463   EXPECT_EQ(Function, N->getFunction());
1464   EXPECT_EQ(TemplateParams, N->getTemplateParams().get());
1465   EXPECT_EQ(Declaration, N->getDeclaration());
1466   EXPECT_EQ(Variables, N->getVariables().get());
1467   EXPECT_EQ(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1468                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1469                                  ContainingType, Virtuality, VirtualIndex,
1470                                  Flags, IsOptimized, Function, TemplateParams,
1471                                  Declaration, Variables));
1472
1473   EXPECT_NE(N, DISubprogram::get(Context, getCompositeType(), Name, LinkageName,
1474                                  File, Line, Type, IsLocalToUnit, IsDefinition,
1475                                  ScopeLine, ContainingType, Virtuality,
1476                                  VirtualIndex, Flags, IsOptimized, Function,
1477                                  TemplateParams, Declaration, Variables));
1478   EXPECT_NE(N, DISubprogram::get(Context, Scope, "other", LinkageName, File,
1479                                  Line, Type, IsLocalToUnit, IsDefinition,
1480                                  ScopeLine, ContainingType, Virtuality,
1481                                  VirtualIndex, Flags, IsOptimized, Function,
1482                                  TemplateParams, Declaration, Variables));
1483   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, "other", File, Line,
1484                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1485                                  ContainingType, Virtuality, VirtualIndex,
1486                                  Flags, IsOptimized, Function, TemplateParams,
1487                                  Declaration, Variables));
1488   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, getFile(),
1489                                  Line, Type, IsLocalToUnit, IsDefinition,
1490                                  ScopeLine, ContainingType, Virtuality,
1491                                  VirtualIndex, Flags, IsOptimized, Function,
1492                                  TemplateParams, Declaration, Variables));
1493   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File,
1494                                  Line + 1, Type, IsLocalToUnit, IsDefinition,
1495                                  ScopeLine, ContainingType, Virtuality,
1496                                  VirtualIndex, Flags, IsOptimized, Function,
1497                                  TemplateParams, Declaration, Variables));
1498   EXPECT_NE(N, DISubprogram::get(
1499                    Context, Scope, Name, LinkageName, File, Line,
1500                    getSubroutineType(), IsLocalToUnit, IsDefinition, ScopeLine,
1501                    ContainingType, Virtuality, VirtualIndex, Flags, IsOptimized,
1502                    Function, TemplateParams, Declaration, Variables));
1503   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1504                                  Type, !IsLocalToUnit, IsDefinition, ScopeLine,
1505                                  ContainingType, Virtuality, VirtualIndex,
1506                                  Flags, IsOptimized, Function, TemplateParams,
1507                                  Declaration, Variables));
1508   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1509                                  Type, IsLocalToUnit, !IsDefinition, ScopeLine,
1510                                  ContainingType, Virtuality, VirtualIndex,
1511                                  Flags, IsOptimized, Function, TemplateParams,
1512                                  Declaration, Variables));
1513   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1514                                  Type, IsLocalToUnit, IsDefinition,
1515                                  ScopeLine + 1, ContainingType, Virtuality,
1516                                  VirtualIndex, Flags, IsOptimized, Function,
1517                                  TemplateParams, Declaration, Variables));
1518   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1519                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1520                                  getCompositeType(), Virtuality, VirtualIndex,
1521                                  Flags, IsOptimized, Function, TemplateParams,
1522                                  Declaration, Variables));
1523   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1524                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1525                                  ContainingType, Virtuality + 1, VirtualIndex,
1526                                  Flags, IsOptimized, Function, TemplateParams,
1527                                  Declaration, Variables));
1528   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1529                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1530                                  ContainingType, Virtuality, VirtualIndex + 1,
1531                                  Flags, IsOptimized, Function, TemplateParams,
1532                                  Declaration, Variables));
1533   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1534                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1535                                  ContainingType, Virtuality, VirtualIndex,
1536                                  ~Flags, IsOptimized, Function, TemplateParams,
1537                                  Declaration, Variables));
1538   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1539                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1540                                  ContainingType, Virtuality, VirtualIndex,
1541                                  Flags, !IsOptimized, Function, TemplateParams,
1542                                  Declaration, Variables));
1543   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1544                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1545                                  ContainingType, Virtuality, VirtualIndex,
1546                                  Flags, IsOptimized, getFunction("bar"),
1547                                  TemplateParams, Declaration, Variables));
1548   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1549                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1550                                  ContainingType, Virtuality, VirtualIndex,
1551                                  Flags, IsOptimized, Function, getTuple(),
1552                                  Declaration, Variables));
1553   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1554                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1555                                  ContainingType, Virtuality, VirtualIndex,
1556                                  Flags, IsOptimized, Function, TemplateParams,
1557                                  getSubprogram(), Variables));
1558   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1559                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1560                                  ContainingType, Virtuality, VirtualIndex,
1561                                  Flags, IsOptimized, Function, TemplateParams,
1562                                  Declaration, getTuple()));
1563
1564   TempDISubprogram Temp = N->clone();
1565   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1566 }
1567
1568 TEST_F(DISubprogramTest, replaceFunction) {
1569   DIScopeRef Scope = getCompositeType();
1570   StringRef Name = "name";
1571   StringRef LinkageName = "linkage";
1572   DIFile *File = getFile();
1573   unsigned Line = 2;
1574   DISubroutineType *Type = getSubroutineType();
1575   bool IsLocalToUnit = false;
1576   bool IsDefinition = true;
1577   unsigned ScopeLine = 3;
1578   DITypeRef ContainingType = getCompositeType();
1579   unsigned Virtuality = 4;
1580   unsigned VirtualIndex = 5;
1581   unsigned Flags = 6;
1582   bool IsOptimized = false;
1583   MDTuple *TemplateParams = getTuple();
1584   DISubprogram *Declaration = getSubprogram();
1585   MDTuple *Variables = getTuple();
1586
1587   auto *N = DISubprogram::get(
1588       Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1589       IsDefinition, ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags,
1590       IsOptimized, nullptr, TemplateParams, Declaration, Variables);
1591
1592   EXPECT_EQ(nullptr, N->getFunction());
1593
1594   std::unique_ptr<Function> F(
1595       Function::Create(FunctionType::get(Type::getVoidTy(Context), false),
1596                        GlobalValue::ExternalLinkage));
1597   N->replaceFunction(F.get());
1598   EXPECT_EQ(F.get(), N->getFunction());
1599
1600   N->replaceFunction(nullptr);
1601   EXPECT_EQ(nullptr, N->getFunction());
1602 }
1603
1604 typedef MetadataTest DILexicalBlockTest;
1605
1606 TEST_F(DILexicalBlockTest, get) {
1607   DILocalScope *Scope = getSubprogram();
1608   DIFile *File = getFile();
1609   unsigned Line = 5;
1610   unsigned Column = 8;
1611
1612   auto *N = DILexicalBlock::get(Context, Scope, File, Line, Column);
1613
1614   EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());
1615   EXPECT_EQ(Scope, N->getScope());
1616   EXPECT_EQ(File, N->getFile());
1617   EXPECT_EQ(Line, N->getLine());
1618   EXPECT_EQ(Column, N->getColumn());
1619   EXPECT_EQ(N, DILexicalBlock::get(Context, Scope, File, Line, Column));
1620
1621   EXPECT_NE(N,
1622             DILexicalBlock::get(Context, getSubprogram(), File, Line, Column));
1623   EXPECT_NE(N, DILexicalBlock::get(Context, Scope, getFile(), Line, Column));
1624   EXPECT_NE(N, DILexicalBlock::get(Context, Scope, File, Line + 1, Column));
1625   EXPECT_NE(N, DILexicalBlock::get(Context, Scope, File, Line, Column + 1));
1626
1627   TempDILexicalBlock Temp = N->clone();
1628   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1629 }
1630
1631 typedef MetadataTest DILexicalBlockFileTest;
1632
1633 TEST_F(DILexicalBlockFileTest, get) {
1634   DILocalScope *Scope = getSubprogram();
1635   DIFile *File = getFile();
1636   unsigned Discriminator = 5;
1637
1638   auto *N = DILexicalBlockFile::get(Context, Scope, File, Discriminator);
1639
1640   EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());
1641   EXPECT_EQ(Scope, N->getScope());
1642   EXPECT_EQ(File, N->getFile());
1643   EXPECT_EQ(Discriminator, N->getDiscriminator());
1644   EXPECT_EQ(N, DILexicalBlockFile::get(Context, Scope, File, Discriminator));
1645
1646   EXPECT_NE(N, DILexicalBlockFile::get(Context, getSubprogram(), File,
1647                                        Discriminator));
1648   EXPECT_NE(N,
1649             DILexicalBlockFile::get(Context, Scope, getFile(), Discriminator));
1650   EXPECT_NE(N,
1651             DILexicalBlockFile::get(Context, Scope, File, Discriminator + 1));
1652
1653   TempDILexicalBlockFile Temp = N->clone();
1654   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1655 }
1656
1657 typedef MetadataTest DINamespaceTest;
1658
1659 TEST_F(DINamespaceTest, get) {
1660   DIScope *Scope = getFile();
1661   DIFile *File = getFile();
1662   StringRef Name = "namespace";
1663   unsigned Line = 5;
1664
1665   auto *N = DINamespace::get(Context, Scope, File, Name, Line);
1666
1667   EXPECT_EQ(dwarf::DW_TAG_namespace, N->getTag());
1668   EXPECT_EQ(Scope, N->getScope());
1669   EXPECT_EQ(File, N->getFile());
1670   EXPECT_EQ(Name, N->getName());
1671   EXPECT_EQ(Line, N->getLine());
1672   EXPECT_EQ(N, DINamespace::get(Context, Scope, File, Name, Line));
1673
1674   EXPECT_NE(N, DINamespace::get(Context, getFile(), File, Name, Line));
1675   EXPECT_NE(N, DINamespace::get(Context, Scope, getFile(), Name, Line));
1676   EXPECT_NE(N, DINamespace::get(Context, Scope, File, "other", Line));
1677   EXPECT_NE(N, DINamespace::get(Context, Scope, File, Name, Line + 1));
1678
1679   TempDINamespace Temp = N->clone();
1680   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1681 }
1682
1683 typedef MetadataTest DITemplateTypeParameterTest;
1684
1685 TEST_F(DITemplateTypeParameterTest, get) {
1686   StringRef Name = "template";
1687   DITypeRef Type = getBasicType("basic");
1688
1689   auto *N = DITemplateTypeParameter::get(Context, Name, Type);
1690
1691   EXPECT_EQ(dwarf::DW_TAG_template_type_parameter, N->getTag());
1692   EXPECT_EQ(Name, N->getName());
1693   EXPECT_EQ(Type, N->getType());
1694   EXPECT_EQ(N, DITemplateTypeParameter::get(Context, Name, Type));
1695
1696   EXPECT_NE(N, DITemplateTypeParameter::get(Context, "other", Type));
1697   EXPECT_NE(N,
1698             DITemplateTypeParameter::get(Context, Name, getBasicType("other")));
1699
1700   TempDITemplateTypeParameter Temp = N->clone();
1701   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1702 }
1703
1704 typedef MetadataTest DITemplateValueParameterTest;
1705
1706 TEST_F(DITemplateValueParameterTest, get) {
1707   unsigned Tag = dwarf::DW_TAG_template_value_parameter;
1708   StringRef Name = "template";
1709   DITypeRef Type = getBasicType("basic");
1710   Metadata *Value = getConstantAsMetadata();
1711
1712   auto *N = DITemplateValueParameter::get(Context, Tag, Name, Type, Value);
1713   EXPECT_EQ(Tag, N->getTag());
1714   EXPECT_EQ(Name, N->getName());
1715   EXPECT_EQ(Type, N->getType());
1716   EXPECT_EQ(Value, N->getValue());
1717   EXPECT_EQ(N, DITemplateValueParameter::get(Context, Tag, Name, Type, Value));
1718
1719   EXPECT_NE(N, DITemplateValueParameter::get(
1720                    Context, dwarf::DW_TAG_GNU_template_template_param, Name,
1721                    Type, Value));
1722   EXPECT_NE(N,
1723             DITemplateValueParameter::get(Context, Tag, "other", Type, Value));
1724   EXPECT_NE(N, DITemplateValueParameter::get(Context, Tag, Name,
1725                                              getBasicType("other"), Value));
1726   EXPECT_NE(N, DITemplateValueParameter::get(Context, Tag, Name, Type,
1727                                              getConstantAsMetadata()));
1728
1729   TempDITemplateValueParameter Temp = N->clone();
1730   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1731 }
1732
1733 typedef MetadataTest DIGlobalVariableTest;
1734
1735 TEST_F(DIGlobalVariableTest, get) {
1736   DIScope *Scope = getSubprogram();
1737   StringRef Name = "name";
1738   StringRef LinkageName = "linkage";
1739   DIFile *File = getFile();
1740   unsigned Line = 5;
1741   DITypeRef Type = getDerivedType();
1742   bool IsLocalToUnit = false;
1743   bool IsDefinition = true;
1744   Constant *Variable = getConstant();
1745   DIDerivedType *StaticDataMemberDeclaration =
1746       cast<DIDerivedType>(getDerivedType());
1747
1748   auto *N = DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,
1749                                   Type, IsLocalToUnit, IsDefinition, Variable,
1750                                   StaticDataMemberDeclaration);
1751   EXPECT_EQ(dwarf::DW_TAG_variable, N->getTag());
1752   EXPECT_EQ(Scope, N->getScope());
1753   EXPECT_EQ(Name, N->getName());
1754   EXPECT_EQ(LinkageName, N->getLinkageName());
1755   EXPECT_EQ(File, N->getFile());
1756   EXPECT_EQ(Line, N->getLine());
1757   EXPECT_EQ(Type, N->getType());
1758   EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());
1759   EXPECT_EQ(IsDefinition, N->isDefinition());
1760   EXPECT_EQ(Variable, N->getVariable());
1761   EXPECT_EQ(StaticDataMemberDeclaration, N->getStaticDataMemberDeclaration());
1762   EXPECT_EQ(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1763                                      Line, Type, IsLocalToUnit, IsDefinition,
1764                                      Variable, StaticDataMemberDeclaration));
1765
1766   EXPECT_NE(N,
1767             DIGlobalVariable::get(Context, getSubprogram(), Name, LinkageName,
1768                                   File, Line, Type, IsLocalToUnit, IsDefinition,
1769                                   Variable, StaticDataMemberDeclaration));
1770   EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, "other", LinkageName, File,
1771                                      Line, Type, IsLocalToUnit, IsDefinition,
1772                                      Variable, StaticDataMemberDeclaration));
1773   EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, "other", File, Line,
1774                                      Type, IsLocalToUnit, IsDefinition,
1775                                      Variable, StaticDataMemberDeclaration));
1776   EXPECT_NE(N,
1777             DIGlobalVariable::get(Context, Scope, Name, LinkageName, getFile(),
1778                                   Line, Type, IsLocalToUnit, IsDefinition,
1779                                   Variable, StaticDataMemberDeclaration));
1780   EXPECT_NE(N,
1781             DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1782                                   Line + 1, Type, IsLocalToUnit, IsDefinition,
1783                                   Variable, StaticDataMemberDeclaration));
1784   EXPECT_NE(N,
1785             DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,
1786                                   getDerivedType(), IsLocalToUnit, IsDefinition,
1787                                   Variable, StaticDataMemberDeclaration));
1788   EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1789                                      Line, Type, !IsLocalToUnit, IsDefinition,
1790                                      Variable, StaticDataMemberDeclaration));
1791   EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1792                                      Line, Type, IsLocalToUnit, !IsDefinition,
1793                                      Variable, StaticDataMemberDeclaration));
1794   EXPECT_NE(N,
1795             DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,
1796                                   Type, IsLocalToUnit, IsDefinition,
1797                                   getConstant(), StaticDataMemberDeclaration));
1798   EXPECT_NE(N,
1799             DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,
1800                                   Type, IsLocalToUnit, IsDefinition, Variable,
1801                                   cast<DIDerivedType>(getDerivedType())));
1802
1803   TempDIGlobalVariable Temp = N->clone();
1804   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1805 }
1806
1807 typedef MetadataTest DILocalVariableTest;
1808
1809 TEST_F(DILocalVariableTest, get) {
1810   unsigned Tag = dwarf::DW_TAG_arg_variable;
1811   DILocalScope *Scope = getSubprogram();
1812   StringRef Name = "name";
1813   DIFile *File = getFile();
1814   unsigned Line = 5;
1815   DITypeRef Type = getDerivedType();
1816   unsigned Arg = 6;
1817   unsigned Flags = 7;
1818
1819   auto *N = DILocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
1820                                  Arg, Flags);
1821   EXPECT_EQ(Tag, N->getTag());
1822   EXPECT_EQ(Scope, N->getScope());
1823   EXPECT_EQ(Name, N->getName());
1824   EXPECT_EQ(File, N->getFile());
1825   EXPECT_EQ(Line, N->getLine());
1826   EXPECT_EQ(Type, N->getType());
1827   EXPECT_EQ(Arg, N->getArg());
1828   EXPECT_EQ(Flags, N->getFlags());
1829   EXPECT_EQ(N, DILocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
1830                                     Arg, Flags));
1831
1832   EXPECT_NE(N, DILocalVariable::get(Context, dwarf::DW_TAG_auto_variable, Scope,
1833                                     Name, File, Line, Type, Arg, Flags));
1834   EXPECT_NE(N, DILocalVariable::get(Context, Tag, getSubprogram(), Name, File,
1835                                     Line, Type, Arg, Flags));
1836   EXPECT_NE(N, DILocalVariable::get(Context, Tag, Scope, "other", File, Line,
1837                                     Type, Arg, Flags));
1838   EXPECT_NE(N, DILocalVariable::get(Context, Tag, Scope, Name, getFile(), Line,
1839                                     Type, Arg, Flags));
1840   EXPECT_NE(N, DILocalVariable::get(Context, Tag, Scope, Name, File, Line + 1,
1841                                     Type, Arg, Flags));
1842   EXPECT_NE(N, DILocalVariable::get(Context, Tag, Scope, Name, File, Line,
1843                                     getDerivedType(), Arg, Flags));
1844   EXPECT_NE(N, DILocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
1845                                     Arg + 1, Flags));
1846   EXPECT_NE(N, DILocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
1847                                     Arg, ~Flags));
1848
1849   TempDILocalVariable Temp = N->clone();
1850   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1851 }
1852
1853 TEST_F(DILocalVariableTest, getArg256) {
1854   EXPECT_EQ(255u, DILocalVariable::get(Context, dwarf::DW_TAG_arg_variable,
1855                                        getSubprogram(), "", getFile(), 0,
1856                                        nullptr, 255, 0)
1857                       ->getArg());
1858   EXPECT_EQ(256u, DILocalVariable::get(Context, dwarf::DW_TAG_arg_variable,
1859                                        getSubprogram(), "", getFile(), 0,
1860                                        nullptr, 256, 0)
1861                       ->getArg());
1862   EXPECT_EQ(257u, DILocalVariable::get(Context, dwarf::DW_TAG_arg_variable,
1863                                        getSubprogram(), "", getFile(), 0,
1864                                        nullptr, 257, 0)
1865                       ->getArg());
1866   unsigned Max = UINT16_MAX;
1867   EXPECT_EQ(Max, DILocalVariable::get(Context, dwarf::DW_TAG_arg_variable,
1868                                       getSubprogram(), "", getFile(), 0,
1869                                       nullptr, Max, 0)
1870                      ->getArg());
1871 }
1872
1873 typedef MetadataTest DIExpressionTest;
1874
1875 TEST_F(DIExpressionTest, get) {
1876   uint64_t Elements[] = {2, 6, 9, 78, 0};
1877   auto *N = DIExpression::get(Context, Elements);
1878   EXPECT_EQ(makeArrayRef(Elements), N->getElements());
1879   EXPECT_EQ(N, DIExpression::get(Context, Elements));
1880
1881   EXPECT_EQ(5u, N->getNumElements());
1882   EXPECT_EQ(2u, N->getElement(0));
1883   EXPECT_EQ(6u, N->getElement(1));
1884   EXPECT_EQ(9u, N->getElement(2));
1885   EXPECT_EQ(78u, N->getElement(3));
1886   EXPECT_EQ(0u, N->getElement(4));
1887
1888   TempDIExpression Temp = N->clone();
1889   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1890 }
1891
1892 TEST_F(DIExpressionTest, isValid) {
1893 #define EXPECT_VALID(...)                                                      \
1894   do {                                                                         \
1895     uint64_t Elements[] = {__VA_ARGS__};                                       \
1896     EXPECT_TRUE(DIExpression::get(Context, Elements)->isValid());              \
1897   } while (false)
1898 #define EXPECT_INVALID(...)                                                    \
1899   do {                                                                         \
1900     uint64_t Elements[] = {__VA_ARGS__};                                       \
1901     EXPECT_FALSE(DIExpression::get(Context, Elements)->isValid());             \
1902   } while (false)
1903
1904   // Empty expression should be valid.
1905   EXPECT_TRUE(DIExpression::get(Context, None));
1906
1907   // Valid constructions.
1908   EXPECT_VALID(dwarf::DW_OP_plus, 6);
1909   EXPECT_VALID(dwarf::DW_OP_deref);
1910   EXPECT_VALID(dwarf::DW_OP_bit_piece, 3, 7);
1911   EXPECT_VALID(dwarf::DW_OP_plus, 6, dwarf::DW_OP_deref);
1912   EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_plus, 6);
1913   EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_bit_piece, 3, 7);
1914   EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_plus, 6, dwarf::DW_OP_bit_piece, 3, 7);
1915
1916   // Invalid constructions.
1917   EXPECT_INVALID(~0u);
1918   EXPECT_INVALID(dwarf::DW_OP_plus);
1919   EXPECT_INVALID(dwarf::DW_OP_bit_piece);
1920   EXPECT_INVALID(dwarf::DW_OP_bit_piece, 3);
1921   EXPECT_INVALID(dwarf::DW_OP_bit_piece, 3, 7, dwarf::DW_OP_plus, 3);
1922   EXPECT_INVALID(dwarf::DW_OP_bit_piece, 3, 7, dwarf::DW_OP_deref);
1923
1924 #undef EXPECT_VALID
1925 #undef EXPECT_INVALID
1926 }
1927
1928 typedef MetadataTest DIObjCPropertyTest;
1929
1930 TEST_F(DIObjCPropertyTest, get) {
1931   StringRef Name = "name";
1932   DIFile *File = getFile();
1933   unsigned Line = 5;
1934   StringRef GetterName = "getter";
1935   StringRef SetterName = "setter";
1936   unsigned Attributes = 7;
1937   DIType *Type = cast<DIBasicType>(getBasicType("basic"));
1938
1939   auto *N = DIObjCProperty::get(Context, Name, File, Line, GetterName,
1940                                 SetterName, Attributes, Type);
1941
1942   EXPECT_EQ(dwarf::DW_TAG_APPLE_property, N->getTag());
1943   EXPECT_EQ(Name, N->getName());
1944   EXPECT_EQ(File, N->getFile());
1945   EXPECT_EQ(Line, N->getLine());
1946   EXPECT_EQ(GetterName, N->getGetterName());
1947   EXPECT_EQ(SetterName, N->getSetterName());
1948   EXPECT_EQ(Attributes, N->getAttributes());
1949   EXPECT_EQ(Type, N->getType());
1950   EXPECT_EQ(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,
1951                                    SetterName, Attributes, Type));
1952
1953   EXPECT_NE(N, DIObjCProperty::get(Context, "other", File, Line, GetterName,
1954                                    SetterName, Attributes, Type));
1955   EXPECT_NE(N, DIObjCProperty::get(Context, Name, getFile(), Line, GetterName,
1956                                    SetterName, Attributes, Type));
1957   EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line + 1, GetterName,
1958                                    SetterName, Attributes, Type));
1959   EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, "other",
1960                                    SetterName, Attributes, Type));
1961   EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,
1962                                    "other", Attributes, Type));
1963   EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,
1964                                    SetterName, Attributes + 1, Type));
1965   EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,
1966                                    SetterName, Attributes,
1967                                    cast<DIBasicType>(getBasicType("other"))));
1968
1969   TempDIObjCProperty Temp = N->clone();
1970   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1971 }
1972
1973 typedef MetadataTest DIImportedEntityTest;
1974
1975 TEST_F(DIImportedEntityTest, get) {
1976   unsigned Tag = dwarf::DW_TAG_imported_module;
1977   DIScope *Scope = getSubprogram();
1978   DINodeRef Entity = getCompositeType();
1979   unsigned Line = 5;
1980   StringRef Name = "name";
1981
1982   auto *N = DIImportedEntity::get(Context, Tag, Scope, Entity, Line, Name);
1983
1984   EXPECT_EQ(Tag, N->getTag());
1985   EXPECT_EQ(Scope, N->getScope());
1986   EXPECT_EQ(Entity, N->getEntity());
1987   EXPECT_EQ(Line, N->getLine());
1988   EXPECT_EQ(Name, N->getName());
1989   EXPECT_EQ(N, DIImportedEntity::get(Context, Tag, Scope, Entity, Line, Name));
1990
1991   EXPECT_NE(N,
1992             DIImportedEntity::get(Context, dwarf::DW_TAG_imported_declaration,
1993                                   Scope, Entity, Line, Name));
1994   EXPECT_NE(N, DIImportedEntity::get(Context, Tag, getSubprogram(), Entity,
1995                                      Line, Name));
1996   EXPECT_NE(N, DIImportedEntity::get(Context, Tag, Scope, getCompositeType(),
1997                                      Line, Name));
1998   EXPECT_NE(N,
1999             DIImportedEntity::get(Context, Tag, Scope, Entity, Line + 1, Name));
2000   EXPECT_NE(N,
2001             DIImportedEntity::get(Context, Tag, Scope, Entity, Line, "other"));
2002
2003   TempDIImportedEntity Temp = N->clone();
2004   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
2005 }
2006
2007 typedef MetadataTest MetadataAsValueTest;
2008
2009 TEST_F(MetadataAsValueTest, MDNode) {
2010   MDNode *N = MDNode::get(Context, None);
2011   auto *V = MetadataAsValue::get(Context, N);
2012   EXPECT_TRUE(V->getType()->isMetadataTy());
2013   EXPECT_EQ(N, V->getMetadata());
2014
2015   auto *V2 = MetadataAsValue::get(Context, N);
2016   EXPECT_EQ(V, V2);
2017 }
2018
2019 TEST_F(MetadataAsValueTest, MDNodeMDNode) {
2020   MDNode *N = MDNode::get(Context, None);
2021   Metadata *Ops[] = {N};
2022   MDNode *N2 = MDNode::get(Context, Ops);
2023   auto *V = MetadataAsValue::get(Context, N2);
2024   EXPECT_TRUE(V->getType()->isMetadataTy());
2025   EXPECT_EQ(N2, V->getMetadata());
2026
2027   auto *V2 = MetadataAsValue::get(Context, N2);
2028   EXPECT_EQ(V, V2);
2029
2030   auto *V3 = MetadataAsValue::get(Context, N);
2031   EXPECT_TRUE(V3->getType()->isMetadataTy());
2032   EXPECT_NE(V, V3);
2033   EXPECT_EQ(N, V3->getMetadata());
2034 }
2035
2036 TEST_F(MetadataAsValueTest, MDNodeConstant) {
2037   auto *C = ConstantInt::getTrue(Context);
2038   auto *MD = ConstantAsMetadata::get(C);
2039   Metadata *Ops[] = {MD};
2040   auto *N = MDNode::get(Context, Ops);
2041
2042   auto *V = MetadataAsValue::get(Context, MD);
2043   EXPECT_TRUE(V->getType()->isMetadataTy());
2044   EXPECT_EQ(MD, V->getMetadata());
2045
2046   auto *V2 = MetadataAsValue::get(Context, N);
2047   EXPECT_EQ(MD, V2->getMetadata());
2048   EXPECT_EQ(V, V2);
2049 }
2050
2051 typedef MetadataTest ValueAsMetadataTest;
2052
2053 TEST_F(ValueAsMetadataTest, UpdatesOnRAUW) {
2054   Type *Ty = Type::getInt1PtrTy(Context);
2055   std::unique_ptr<GlobalVariable> GV0(
2056       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
2057   auto *MD = ValueAsMetadata::get(GV0.get());
2058   EXPECT_TRUE(MD->getValue() == GV0.get());
2059   ASSERT_TRUE(GV0->use_empty());
2060
2061   std::unique_ptr<GlobalVariable> GV1(
2062       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
2063   GV0->replaceAllUsesWith(GV1.get());
2064   EXPECT_TRUE(MD->getValue() == GV1.get());
2065 }
2066
2067 TEST_F(ValueAsMetadataTest, CollidingDoubleUpdates) {
2068   // Create a constant.
2069   ConstantAsMetadata *CI = ConstantAsMetadata::get(
2070       ConstantInt::get(getGlobalContext(), APInt(8, 0)));
2071
2072   // Create a temporary to prevent nodes from resolving.
2073   auto Temp = MDTuple::getTemporary(Context, None);
2074
2075   // When the first operand of N1 gets reset to nullptr, it'll collide with N2.
2076   Metadata *Ops1[] = {CI, CI, Temp.get()};
2077   Metadata *Ops2[] = {nullptr, CI, Temp.get()};
2078
2079   auto *N1 = MDTuple::get(Context, Ops1);
2080   auto *N2 = MDTuple::get(Context, Ops2);
2081   ASSERT_NE(N1, N2);
2082
2083   // Tell metadata that the constant is getting deleted.
2084   //
2085   // After this, N1 will be invalid, so don't touch it.
2086   ValueAsMetadata::handleDeletion(CI->getValue());
2087   EXPECT_EQ(nullptr, N2->getOperand(0));
2088   EXPECT_EQ(nullptr, N2->getOperand(1));
2089   EXPECT_EQ(Temp.get(), N2->getOperand(2));
2090
2091   // Clean up Temp for teardown.
2092   Temp->replaceAllUsesWith(nullptr);
2093 }
2094
2095 typedef MetadataTest TrackingMDRefTest;
2096
2097 TEST_F(TrackingMDRefTest, UpdatesOnRAUW) {
2098   Type *Ty = Type::getInt1PtrTy(Context);
2099   std::unique_ptr<GlobalVariable> GV0(
2100       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
2101   TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV0.get()));
2102   EXPECT_TRUE(MD->getValue() == GV0.get());
2103   ASSERT_TRUE(GV0->use_empty());
2104
2105   std::unique_ptr<GlobalVariable> GV1(
2106       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
2107   GV0->replaceAllUsesWith(GV1.get());
2108   EXPECT_TRUE(MD->getValue() == GV1.get());
2109
2110   // Reset it, so we don't inadvertently test deletion.
2111   MD.reset();
2112 }
2113
2114 TEST_F(TrackingMDRefTest, UpdatesOnDeletion) {
2115   Type *Ty = Type::getInt1PtrTy(Context);
2116   std::unique_ptr<GlobalVariable> GV(
2117       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
2118   TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV.get()));
2119   EXPECT_TRUE(MD->getValue() == GV.get());
2120   ASSERT_TRUE(GV->use_empty());
2121
2122   GV.reset();
2123   EXPECT_TRUE(!MD);
2124 }
2125
2126 TEST(NamedMDNodeTest, Search) {
2127   LLVMContext Context;
2128   ConstantAsMetadata *C =
2129       ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 1));
2130   ConstantAsMetadata *C2 =
2131       ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 2));
2132
2133   Metadata *const V = C;
2134   Metadata *const V2 = C2;
2135   MDNode *n = MDNode::get(Context, V);
2136   MDNode *n2 = MDNode::get(Context, V2);
2137
2138   Module M("MyModule", Context);
2139   const char *Name = "llvm.NMD1";
2140   NamedMDNode *NMD = M.getOrInsertNamedMetadata(Name);
2141   NMD->addOperand(n);
2142   NMD->addOperand(n2);
2143
2144   std::string Str;
2145   raw_string_ostream oss(Str);
2146   NMD->print(oss);
2147   EXPECT_STREQ("!llvm.NMD1 = !{!0, !1}\n",
2148                oss.str().c_str());
2149 }
2150
2151 typedef MetadataTest FunctionAttachmentTest;
2152 TEST_F(FunctionAttachmentTest, setMetadata) {
2153   Function *F = getFunction("foo");
2154   ASSERT_FALSE(F->hasMetadata());
2155   EXPECT_EQ(nullptr, F->getMetadata(LLVMContext::MD_dbg));
2156   EXPECT_EQ(nullptr, F->getMetadata("dbg"));
2157   EXPECT_EQ(nullptr, F->getMetadata("other"));
2158
2159   DISubprogram *SP1 = getSubprogram();
2160   DISubprogram *SP2 = getSubprogram();
2161   ASSERT_NE(SP1, SP2);
2162
2163   F->setMetadata("dbg", SP1);
2164   EXPECT_TRUE(F->hasMetadata());
2165   EXPECT_EQ(SP1, F->getMetadata(LLVMContext::MD_dbg));
2166   EXPECT_EQ(SP1, F->getMetadata("dbg"));
2167   EXPECT_EQ(nullptr, F->getMetadata("other"));
2168
2169   F->setMetadata(LLVMContext::MD_dbg, SP2);
2170   EXPECT_TRUE(F->hasMetadata());
2171   EXPECT_EQ(SP2, F->getMetadata(LLVMContext::MD_dbg));
2172   EXPECT_EQ(SP2, F->getMetadata("dbg"));
2173   EXPECT_EQ(nullptr, F->getMetadata("other"));
2174
2175   F->setMetadata("dbg", nullptr);
2176   EXPECT_FALSE(F->hasMetadata());
2177   EXPECT_EQ(nullptr, F->getMetadata(LLVMContext::MD_dbg));
2178   EXPECT_EQ(nullptr, F->getMetadata("dbg"));
2179   EXPECT_EQ(nullptr, F->getMetadata("other"));
2180
2181   MDTuple *T1 = getTuple();
2182   MDTuple *T2 = getTuple();
2183   ASSERT_NE(T1, T2);
2184
2185   F->setMetadata("other1", T1);
2186   F->setMetadata("other2", T2);
2187   EXPECT_TRUE(F->hasMetadata());
2188   EXPECT_EQ(T1, F->getMetadata("other1"));
2189   EXPECT_EQ(T2, F->getMetadata("other2"));
2190   EXPECT_EQ(nullptr, F->getMetadata("dbg"));
2191
2192   F->setMetadata("other1", T2);
2193   F->setMetadata("other2", T1);
2194   EXPECT_EQ(T2, F->getMetadata("other1"));
2195   EXPECT_EQ(T1, F->getMetadata("other2"));
2196
2197   F->setMetadata("other1", nullptr);
2198   F->setMetadata("other2", nullptr);
2199   EXPECT_FALSE(F->hasMetadata());
2200   EXPECT_EQ(nullptr, F->getMetadata("other1"));
2201   EXPECT_EQ(nullptr, F->getMetadata("other2"));
2202 }
2203
2204 TEST_F(FunctionAttachmentTest, getAll) {
2205   Function *F = getFunction("foo");
2206
2207   MDTuple *T1 = getTuple();
2208   MDTuple *T2 = getTuple();
2209   MDTuple *P = getTuple();
2210   DISubprogram *SP = getSubprogram();
2211
2212   F->setMetadata("other1", T2);
2213   F->setMetadata(LLVMContext::MD_dbg, SP);
2214   F->setMetadata("other2", T1);
2215   F->setMetadata(LLVMContext::MD_prof, P);
2216   F->setMetadata("other2", T2);
2217   F->setMetadata("other1", T1);
2218
2219   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
2220   F->getAllMetadata(MDs);
2221   ASSERT_EQ(4u, MDs.size());
2222   EXPECT_EQ(LLVMContext::MD_dbg, MDs[0].first);
2223   EXPECT_EQ(LLVMContext::MD_prof, MDs[1].first);
2224   EXPECT_EQ(Context.getMDKindID("other1"), MDs[2].first);
2225   EXPECT_EQ(Context.getMDKindID("other2"), MDs[3].first);
2226   EXPECT_EQ(SP, MDs[0].second);
2227   EXPECT_EQ(P, MDs[1].second);
2228   EXPECT_EQ(T1, MDs[2].second);
2229   EXPECT_EQ(T2, MDs[3].second);
2230 }
2231
2232 TEST_F(FunctionAttachmentTest, dropUnknownMetadata) {
2233   Function *F = getFunction("foo");
2234
2235   MDTuple *T1 = getTuple();
2236   MDTuple *T2 = getTuple();
2237   MDTuple *P = getTuple();
2238   DISubprogram *SP = getSubprogram();
2239
2240   F->setMetadata("other1", T1);
2241   F->setMetadata(LLVMContext::MD_dbg, SP);
2242   F->setMetadata("other2", T2);
2243   F->setMetadata(LLVMContext::MD_prof, P);
2244
2245   unsigned Known[] = {Context.getMDKindID("other2"), LLVMContext::MD_prof};
2246   F->dropUnknownMetadata(Known);
2247
2248   EXPECT_EQ(T2, F->getMetadata("other2"));
2249   EXPECT_EQ(P, F->getMetadata(LLVMContext::MD_prof));
2250   EXPECT_EQ(nullptr, F->getMetadata("other1"));
2251   EXPECT_EQ(nullptr, F->getMetadata(LLVMContext::MD_dbg));
2252
2253   F->setMetadata("other2", nullptr);
2254   F->setMetadata(LLVMContext::MD_prof, nullptr);
2255   EXPECT_FALSE(F->hasMetadata());
2256 }
2257
2258 TEST_F(FunctionAttachmentTest, Verifier) {
2259   Function *F = getFunction("foo");
2260   F->setMetadata("attach", getTuple());
2261
2262   // Confirm this has no body.
2263   ASSERT_TRUE(F->empty());
2264
2265   // Functions without a body cannot have metadata attachments (they also can't
2266   // be verified directly, so check that the module fails to verify).
2267   EXPECT_TRUE(verifyModule(*F->getParent()));
2268
2269   // Functions with a body can.
2270   (void)new UnreachableInst(Context, BasicBlock::Create(Context, "bb", F));
2271   EXPECT_FALSE(verifyModule(*F->getParent()));
2272   EXPECT_FALSE(verifyFunction(*F));
2273 }
2274
2275 }