unittests/IR/MetadataTest.cpp

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