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