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/DebugInfoMetadata.h"
  13 #include "llvm/IR/Function.h"
  14 #include "llvm/IR/Instructions.h"
  15 #include "llvm/IR/LLVMContext.h"
  16 #include "llvm/IR/Metadata.h"
  17 #include "llvm/IR/Module.h"
  18 #include "llvm/IR/Type.h"
  19 #include "llvm/Support/raw_ostream.h"
  20 #include "gtest/gtest.h"
  21 using namespace llvm;
  22
  23 namespace {
  24
  25 TEST(ContextAndReplaceableUsesTest, FromContext) {
  26   LLVMContext Context;
  27   ContextAndReplaceableUses CRU(Context);
  28   EXPECT_EQ(&Context, &CRU.getContext());
  29   EXPECT_FALSE(CRU.hasReplaceableUses());
  30   EXPECT_FALSE(CRU.getReplaceableUses());
  31 }
  32
  33 TEST(ContextAndReplaceableUsesTest, FromReplaceableUses) {
  34   LLVMContext Context;
  35   ContextAndReplaceableUses CRU(make_unique<ReplaceableMetadataImpl>(Context));
  36   EXPECT_EQ(&Context, &CRU.getContext());
  37   EXPECT_TRUE(CRU.hasReplaceableUses());
  38   EXPECT_TRUE(CRU.getReplaceableUses());
  39 }
  40
  41 TEST(ContextAndReplaceableUsesTest, makeReplaceable) {
  42   LLVMContext Context;
  43   ContextAndReplaceableUses CRU(Context);
  44   CRU.makeReplaceable(make_unique<ReplaceableMetadataImpl>(Context));
  45   EXPECT_EQ(&Context, &CRU.getContext());
  46   EXPECT_TRUE(CRU.hasReplaceableUses());
  47   EXPECT_TRUE(CRU.getReplaceableUses());
  48 }
  49
  50 TEST(ContextAndReplaceableUsesTest, takeReplaceableUses) {
  51   LLVMContext Context;
  52   auto ReplaceableUses = make_unique<ReplaceableMetadataImpl>(Context);
  53   auto *Ptr = ReplaceableUses.get();
  54   ContextAndReplaceableUses CRU(std::move(ReplaceableUses));
  55   ReplaceableUses = CRU.takeReplaceableUses();
  56   EXPECT_EQ(&Context, &CRU.getContext());
  57   EXPECT_FALSE(CRU.hasReplaceableUses());
  58   EXPECT_FALSE(CRU.getReplaceableUses());
  59   EXPECT_EQ(Ptr, ReplaceableUses.get());
  60 }
  61
  62 class MetadataTest : public testing::Test {
  63 protected:
  64   LLVMContext Context;
  65   MDNode *getNode() { return MDNode::get(Context, None); }
  66   MDNode *getNode(Metadata *MD) { return MDNode::get(Context, MD); }
  67   MDNode *getNode(Metadata *MD1, Metadata *MD2) {
  68     Metadata *MDs[] = {MD1, MD2};
  69     return MDNode::get(Context, MDs);
  70   }
  71 };
  72 typedef MetadataTest MDStringTest;
  73
  74 // Test that construction of MDString with different value produces different
  75 // MDString objects, even with the same string pointer and nulls in the string.
  76 TEST_F(MDStringTest, CreateDifferent) {
  77   char x[3] = { 'f', 0, 'A' };
  78   MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
  79   x[2] = 'B';
  80   MDString *s2 = MDString::get(Context, StringRef(&x[0], 3));
  81   EXPECT_NE(s1, s2);
  82 }
  83
  84 // Test that creation of MDStrings with the same string contents produces the
  85 // same MDString object, even with different pointers.
  86 TEST_F(MDStringTest, CreateSame) {
  87   char x[4] = { 'a', 'b', 'c', 'X' };
  88   char y[4] = { 'a', 'b', 'c', 'Y' };
  89
  90   MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
  91   MDString *s2 = MDString::get(Context, StringRef(&y[0], 3));
  92   EXPECT_EQ(s1, s2);
  93 }
  94
  95 // Test that MDString prints out the string we fed it.
  96 TEST_F(MDStringTest, PrintingSimple) {
  97   char *str = new char[13];
  98   strncpy(str, "testing 1 2 3", 13);
  99   MDString *s = MDString::get(Context, StringRef(str, 13));
 100   strncpy(str, "aaaaaaaaaaaaa", 13);
 101   delete[] str;
 102
 103   std::string Str;
 104   raw_string_ostream oss(Str);
 105   s->print(oss);
 106   EXPECT_STREQ("!\"testing 1 2 3\"", oss.str().c_str());
 107 }
 108
 109 // Test printing of MDString with non-printable characters.
 110 TEST_F(MDStringTest, PrintingComplex) {
 111   char str[5] = {0, '\n', '"', '\\', (char)-1};
 112   MDString *s = MDString::get(Context, StringRef(str+0, 5));
 113   std::string Str;
 114   raw_string_ostream oss(Str);
 115   s->print(oss);
 116   EXPECT_STREQ("!\"\\00\\0A\\22\\5C\\FF\"", oss.str().c_str());
 117 }
 118
 119 typedef MetadataTest MDNodeTest;
 120
 121 // Test the two constructors, and containing other Constants.
 122 TEST_F(MDNodeTest, Simple) {
 123   char x[3] = { 'a', 'b', 'c' };
 124   char y[3] = { '1', '2', '3' };
 125
 126   MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
 127   MDString *s2 = MDString::get(Context, StringRef(&y[0], 3));
 128   ConstantAsMetadata *CI = ConstantAsMetadata::get(
 129       ConstantInt::get(getGlobalContext(), APInt(8, 0)));
 130
 131   std::vector<Metadata *> V;
 132   V.push_back(s1);
 133   V.push_back(CI);
 134   V.push_back(s2);
 135
 136   MDNode *n1 = MDNode::get(Context, V);
 137   Metadata *const c1 = n1;
 138   MDNode *n2 = MDNode::get(Context, c1);
 139   Metadata *const c2 = n2;
 140   MDNode *n3 = MDNode::get(Context, V);
 141   MDNode *n4 = MDNode::getIfExists(Context, V);
 142   MDNode *n5 = MDNode::getIfExists(Context, c1);
 143   MDNode *n6 = MDNode::getIfExists(Context, c2);
 144   EXPECT_NE(n1, n2);
 145   EXPECT_EQ(n1, n3);
 146   EXPECT_EQ(n4, n1);
 147   EXPECT_EQ(n5, n2);
 148   EXPECT_EQ(n6, (Metadata *)nullptr);
 149
 150   EXPECT_EQ(3u, n1->getNumOperands());
 151   EXPECT_EQ(s1, n1->getOperand(0));
 152   EXPECT_EQ(CI, n1->getOperand(1));
 153   EXPECT_EQ(s2, n1->getOperand(2));
 154
 155   EXPECT_EQ(1u, n2->getNumOperands());
 156   EXPECT_EQ(n1, n2->getOperand(0));
 157 }
 158
 159 TEST_F(MDNodeTest, Delete) {
 160   Constant *C = ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 1);
 161   Instruction *I = new BitCastInst(C, Type::getInt32Ty(getGlobalContext()));
 162
 163   Metadata *const V = LocalAsMetadata::get(I);
 164   MDNode *n = MDNode::get(Context, V);
 165   TrackingMDRef wvh(n);
 166
 167   EXPECT_EQ(n, wvh);
 168
 169   delete I;
 170 }
 171
 172 TEST_F(MDNodeTest, SelfReference) {
 173   // !0 = !{!0}
 174   // !1 = !{!0}
 175   {
 176     auto Temp = MDNode::getTemporary(Context, None);
 177     Metadata *Args[] = {Temp.get()};
 178     MDNode *Self = MDNode::get(Context, Args);
 179     Self->replaceOperandWith(0, Self);
 180     ASSERT_EQ(Self, Self->getOperand(0));
 181
 182     // Self-references should be distinct, so MDNode::get() should grab a
 183     // uniqued node that references Self, not Self.
 184     Args[0] = Self;
 185     MDNode *Ref1 = MDNode::get(Context, Args);
 186     MDNode *Ref2 = MDNode::get(Context, Args);
 187     EXPECT_NE(Self, Ref1);
 188     EXPECT_EQ(Ref1, Ref2);
 189   }
 190
 191   // !0 = !{!0, !{}}
 192   // !1 = !{!0, !{}}
 193   {
 194     auto Temp = MDNode::getTemporary(Context, None);
 195     Metadata *Args[] = {Temp.get(), MDNode::get(Context, None)};
 196     MDNode *Self = MDNode::get(Context, Args);
 197     Self->replaceOperandWith(0, Self);
 198     ASSERT_EQ(Self, Self->getOperand(0));
 199
 200     // Self-references should be distinct, so MDNode::get() should grab a
 201     // uniqued node that references Self, not Self itself.
 202     Args[0] = Self;
 203     MDNode *Ref1 = MDNode::get(Context, Args);
 204     MDNode *Ref2 = MDNode::get(Context, Args);
 205     EXPECT_NE(Self, Ref1);
 206     EXPECT_EQ(Ref1, Ref2);
 207   }
 208 }
 209
 210 TEST_F(MDNodeTest, Print) {
 211   Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 7);
 212   MDString *S = MDString::get(Context, "foo");
 213   MDNode *N0 = getNode();
 214   MDNode *N1 = getNode(N0);
 215   MDNode *N2 = getNode(N0, N1);
 216
 217   Metadata *Args[] = {ConstantAsMetadata::get(C), S, nullptr, N0, N1, N2};
 218   MDNode *N = MDNode::get(Context, Args);
 219
 220   std::string Expected;
 221   {
 222     raw_string_ostream OS(Expected);
 223     OS << "!{";
 224     C->printAsOperand(OS);
 225     OS << ", ";
 226     S->printAsOperand(OS);
 227     OS << ", null";
 228     MDNode *Nodes[] = {N0, N1, N2};
 229     for (auto *Node : Nodes)
 230       OS << ", <" << (void *)Node << ">";
 231     OS << "}\n";
 232   }
 233
 234   std::string Actual;
 235   {
 236     raw_string_ostream OS(Actual);
 237     N->print(OS);
 238   }
 239
 240   EXPECT_EQ(Expected, Actual);
 241 }
 242
 243 TEST_F(MDNodeTest, NullOperand) {
 244   // metadata !{}
 245   MDNode *Empty = MDNode::get(Context, None);
 246
 247   // metadata !{metadata !{}}
 248   Metadata *Ops[] = {Empty};
 249   MDNode *N = MDNode::get(Context, Ops);
 250   ASSERT_EQ(Empty, N->getOperand(0));
 251
 252   // metadata !{metadata !{}} => metadata !{null}
 253   N->replaceOperandWith(0, nullptr);
 254   ASSERT_EQ(nullptr, N->getOperand(0));
 255
 256   // metadata !{null}
 257   Ops[0] = nullptr;
 258   MDNode *NullOp = MDNode::get(Context, Ops);
 259   ASSERT_EQ(nullptr, NullOp->getOperand(0));
 260   EXPECT_EQ(N, NullOp);
 261 }
 262
 263 TEST_F(MDNodeTest, DistinctOnUniquingCollision) {
 264   // !{}
 265   MDNode *Empty = MDNode::get(Context, None);
 266   ASSERT_TRUE(Empty->isResolved());
 267   EXPECT_FALSE(Empty->isDistinct());
 268
 269   // !{!{}}
 270   Metadata *Wrapped1Ops[] = {Empty};
 271   MDNode *Wrapped1 = MDNode::get(Context, Wrapped1Ops);
 272   ASSERT_EQ(Empty, Wrapped1->getOperand(0));
 273   ASSERT_TRUE(Wrapped1->isResolved());
 274   EXPECT_FALSE(Wrapped1->isDistinct());
 275
 276   // !{!{!{}}}
 277   Metadata *Wrapped2Ops[] = {Wrapped1};
 278   MDNode *Wrapped2 = MDNode::get(Context, Wrapped2Ops);
 279   ASSERT_EQ(Wrapped1, Wrapped2->getOperand(0));
 280   ASSERT_TRUE(Wrapped2->isResolved());
 281   EXPECT_FALSE(Wrapped2->isDistinct());
 282
 283   // !{!{!{}}} => !{!{}}
 284   Wrapped2->replaceOperandWith(0, Empty);
 285   ASSERT_EQ(Empty, Wrapped2->getOperand(0));
 286   EXPECT_TRUE(Wrapped2->isDistinct());
 287   EXPECT_FALSE(Wrapped1->isDistinct());
 288 }
 289
 290 TEST_F(MDNodeTest, getDistinct) {
 291   // !{}
 292   MDNode *Empty = MDNode::get(Context, None);
 293   ASSERT_TRUE(Empty->isResolved());
 294   ASSERT_FALSE(Empty->isDistinct());
 295   ASSERT_EQ(Empty, MDNode::get(Context, None));
 296
 297   // distinct !{}
 298   MDNode *Distinct1 = MDNode::getDistinct(Context, None);
 299   MDNode *Distinct2 = MDNode::getDistinct(Context, None);
 300   EXPECT_TRUE(Distinct1->isResolved());
 301   EXPECT_TRUE(Distinct2->isDistinct());
 302   EXPECT_NE(Empty, Distinct1);
 303   EXPECT_NE(Empty, Distinct2);
 304   EXPECT_NE(Distinct1, Distinct2);
 305
 306   // !{}
 307   ASSERT_EQ(Empty, MDNode::get(Context, None));
 308 }
 309
 310 TEST_F(MDNodeTest, isUniqued) {
 311   MDNode *U = MDTuple::get(Context, None);
 312   MDNode *D = MDTuple::getDistinct(Context, None);
 313   auto T = MDTuple::getTemporary(Context, None);
 314   EXPECT_TRUE(U->isUniqued());
 315   EXPECT_FALSE(D->isUniqued());
 316   EXPECT_FALSE(T->isUniqued());
 317 }
 318
 319 TEST_F(MDNodeTest, isDistinct) {
 320   MDNode *U = MDTuple::get(Context, None);
 321   MDNode *D = MDTuple::getDistinct(Context, None);
 322   auto T = MDTuple::getTemporary(Context, None);
 323   EXPECT_FALSE(U->isDistinct());
 324   EXPECT_TRUE(D->isDistinct());
 325   EXPECT_FALSE(T->isDistinct());
 326 }
 327
 328 TEST_F(MDNodeTest, isTemporary) {
 329   MDNode *U = MDTuple::get(Context, None);
 330   MDNode *D = MDTuple::getDistinct(Context, None);
 331   auto T = MDTuple::getTemporary(Context, None);
 332   EXPECT_FALSE(U->isTemporary());
 333   EXPECT_FALSE(D->isTemporary());
 334   EXPECT_TRUE(T->isTemporary());
 335 }
 336
 337 TEST_F(MDNodeTest, getDistinctWithUnresolvedOperands) {
 338   // temporary !{}
 339   auto Temp = MDTuple::getTemporary(Context, None);
 340   ASSERT_FALSE(Temp->isResolved());
 341
 342   // distinct !{temporary !{}}
 343   Metadata *Ops[] = {Temp.get()};
 344   MDNode *Distinct = MDNode::getDistinct(Context, Ops);
 345   EXPECT_TRUE(Distinct->isResolved());
 346   EXPECT_EQ(Temp.get(), Distinct->getOperand(0));
 347
 348   // temporary !{} => !{}
 349   MDNode *Empty = MDNode::get(Context, None);
 350   Temp->replaceAllUsesWith(Empty);
 351   EXPECT_EQ(Empty, Distinct->getOperand(0));
 352 }
 353
 354 TEST_F(MDNodeTest, handleChangedOperandRecursion) {
 355   // !0 = !{}
 356   MDNode *N0 = MDNode::get(Context, None);
 357
 358   // !1 = !{!3, null}
 359   auto Temp3 = MDTuple::getTemporary(Context, None);
 360   Metadata *Ops1[] = {Temp3.get(), nullptr};
 361   MDNode *N1 = MDNode::get(Context, Ops1);
 362
 363   // !2 = !{!3, !0}
 364   Metadata *Ops2[] = {Temp3.get(), N0};
 365   MDNode *N2 = MDNode::get(Context, Ops2);
 366
 367   // !3 = !{!2}
 368   Metadata *Ops3[] = {N2};
 369   MDNode *N3 = MDNode::get(Context, Ops3);
 370   Temp3->replaceAllUsesWith(N3);
 371
 372   // !4 = !{!1}
 373   Metadata *Ops4[] = {N1};
 374   MDNode *N4 = MDNode::get(Context, Ops4);
 375
 376   // Confirm that the cycle prevented RAUW from getting dropped.
 377   EXPECT_TRUE(N0->isResolved());
 378   EXPECT_FALSE(N1->isResolved());
 379   EXPECT_FALSE(N2->isResolved());
 380   EXPECT_FALSE(N3->isResolved());
 381   EXPECT_FALSE(N4->isResolved());
 382
 383   // Create a couple of distinct nodes to observe what's going on.
 384   //
 385   // !5 = distinct !{!2}
 386   // !6 = distinct !{!3}
 387   Metadata *Ops5[] = {N2};
 388   MDNode *N5 = MDNode::getDistinct(Context, Ops5);
 389   Metadata *Ops6[] = {N3};
 390   MDNode *N6 = MDNode::getDistinct(Context, Ops6);
 391
 392   // Mutate !2 to look like !1, causing a uniquing collision (and an RAUW).
 393   // This will ripple up, with !3 colliding with !4, and RAUWing.  Since !2
 394   // references !3, this can cause a re-entry of handleChangedOperand() when !3
 395   // is not ready for it.
 396   //
 397   // !2->replaceOperandWith(1, nullptr)
 398   // !2: !{!3, !0} => !{!3, null}
 399   // !2->replaceAllUsesWith(!1)
 400   // !3: !{!2] => !{!1}
 401   // !3->replaceAllUsesWith(!4)
 402   N2->replaceOperandWith(1, nullptr);
 403
 404   // If all has gone well, N2 and N3 will have been RAUW'ed and deleted from
 405   // under us.  Just check that the other nodes are sane.
 406   //
 407   // !1 = !{!4, null}
 408   // !4 = !{!1}
 409   // !5 = distinct !{!1}
 410   // !6 = distinct !{!4}
 411   EXPECT_EQ(N4, N1->getOperand(0));
 412   EXPECT_EQ(N1, N4->getOperand(0));
 413   EXPECT_EQ(N1, N5->getOperand(0));
 414   EXPECT_EQ(N4, N6->getOperand(0));
 415 }
 416
 417 TEST_F(MDNodeTest, replaceResolvedOperand) {
 418   // Check code for replacing one resolved operand with another.  If doing this
 419   // directly (via replaceOperandWith()) becomes illegal, change the operand to
 420   // a global value that gets RAUW'ed.
 421   //
 422   // Use a temporary node to keep N from being resolved.
 423   auto Temp = MDTuple::getTemporary(Context, None);
 424   Metadata *Ops[] = {nullptr, Temp.get()};
 425
 426   MDNode *Empty = MDTuple::get(Context, ArrayRef<Metadata *>());
 427   MDNode *N = MDTuple::get(Context, Ops);
 428   EXPECT_EQ(nullptr, N->getOperand(0));
 429   ASSERT_FALSE(N->isResolved());
 430
 431   // Check code for replacing resolved nodes.
 432   N->replaceOperandWith(0, Empty);
 433   EXPECT_EQ(Empty, N->getOperand(0));
 434
 435   // Check code for adding another unresolved operand.
 436   N->replaceOperandWith(0, Temp.get());
 437   EXPECT_EQ(Temp.get(), N->getOperand(0));
 438
 439   // Remove the references to Temp; required for teardown.
 440   Temp->replaceAllUsesWith(nullptr);
 441 }
 442
 443 TEST_F(MDNodeTest, replaceWithUniqued) {
 444   auto *Empty = MDTuple::get(Context, None);
 445   MDTuple *FirstUniqued;
 446   {
 447     Metadata *Ops[] = {Empty};
 448     auto Temp = MDTuple::getTemporary(Context, Ops);
 449     EXPECT_TRUE(Temp->isTemporary());
 450
 451     // Don't expect a collision.
 452     auto *Current = Temp.get();
 453     FirstUniqued = MDNode::replaceWithUniqued(std::move(Temp));
 454     EXPECT_TRUE(FirstUniqued->isUniqued());
 455     EXPECT_TRUE(FirstUniqued->isResolved());
 456     EXPECT_EQ(Current, FirstUniqued);
 457   }
 458   {
 459     Metadata *Ops[] = {Empty};
 460     auto Temp = MDTuple::getTemporary(Context, Ops);
 461     EXPECT_TRUE(Temp->isTemporary());
 462
 463     // Should collide with Uniqued above this time.
 464     auto *Uniqued = MDNode::replaceWithUniqued(std::move(Temp));
 465     EXPECT_TRUE(Uniqued->isUniqued());
 466     EXPECT_TRUE(Uniqued->isResolved());
 467     EXPECT_EQ(FirstUniqued, Uniqued);
 468   }
 469   {
 470     auto Unresolved = MDTuple::getTemporary(Context, None);
 471     Metadata *Ops[] = {Unresolved.get()};
 472     auto Temp = MDTuple::getTemporary(Context, Ops);
 473     EXPECT_TRUE(Temp->isTemporary());
 474
 475     // Shouldn't be resolved.
 476     auto *Uniqued = MDNode::replaceWithUniqued(std::move(Temp));
 477     EXPECT_TRUE(Uniqued->isUniqued());
 478     EXPECT_FALSE(Uniqued->isResolved());
 479
 480     // Should be a different node.
 481     EXPECT_NE(FirstUniqued, Uniqued);
 482
 483     // Should resolve when we update its node (note: be careful to avoid a
 484     // collision with any other nodes above).
 485     Uniqued->replaceOperandWith(0, nullptr);
 486     EXPECT_TRUE(Uniqued->isResolved());
 487   }
 488 }
 489
 490 TEST_F(MDNodeTest, replaceWithDistinct) {
 491   {
 492     auto *Empty = MDTuple::get(Context, None);
 493     Metadata *Ops[] = {Empty};
 494     auto Temp = MDTuple::getTemporary(Context, Ops);
 495     EXPECT_TRUE(Temp->isTemporary());
 496
 497     // Don't expect a collision.
 498     auto *Current = Temp.get();
 499     auto *Distinct = MDNode::replaceWithDistinct(std::move(Temp));
 500     EXPECT_TRUE(Distinct->isDistinct());
 501     EXPECT_TRUE(Distinct->isResolved());
 502     EXPECT_EQ(Current, Distinct);
 503   }
 504   {
 505     auto Unresolved = MDTuple::getTemporary(Context, None);
 506     Metadata *Ops[] = {Unresolved.get()};
 507     auto Temp = MDTuple::getTemporary(Context, Ops);
 508     EXPECT_TRUE(Temp->isTemporary());
 509
 510     // Don't expect a collision.
 511     auto *Current = Temp.get();
 512     auto *Distinct = MDNode::replaceWithDistinct(std::move(Temp));
 513     EXPECT_TRUE(Distinct->isDistinct());
 514     EXPECT_TRUE(Distinct->isResolved());
 515     EXPECT_EQ(Current, Distinct);
 516
 517     // Cleanup; required for teardown.
 518     Unresolved->replaceAllUsesWith(nullptr);
 519   }
 520 }
 521
 522 TEST_F(MDNodeTest, replaceWithPermanent) {
 523   Metadata *Ops[] = {nullptr};
 524   auto Temp = MDTuple::getTemporary(Context, Ops);
 525   auto *T = Temp.get();
 526
 527   // U is a normal, uniqued node that references T.
 528   auto *U = MDTuple::get(Context, T);
 529   EXPECT_TRUE(U->isUniqued());
 530
 531   // Make Temp self-referencing.
 532   Temp->replaceOperandWith(0, T);
 533
 534   // Try to uniquify Temp.  This should, despite the name in the API, give a
 535   // 'distinct' node, since self-references aren't allowed to be uniqued.
 536   //
 537   // Since it's distinct, N should have the same address as when it was a
 538   // temporary (i.e., be equal to T not U).
 539   auto *N = MDNode::replaceWithPermanent(std::move(Temp));
 540   EXPECT_EQ(N, T);
 541   EXPECT_TRUE(N->isDistinct());
 542
 543   // U should be the canonical unique node with N as the argument.
 544   EXPECT_EQ(U, MDTuple::get(Context, N));
 545   EXPECT_TRUE(U->isUniqued());
 546
 547   // This temporary should collide with U when replaced, but it should still be
 548   // uniqued.
 549   EXPECT_EQ(U, MDNode::replaceWithPermanent(MDTuple::getTemporary(Context, N)));
 550   EXPECT_TRUE(U->isUniqued());
 551
 552   // This temporary should become a new uniqued node.
 553   auto Temp2 = MDTuple::getTemporary(Context, U);
 554   auto *V = Temp2.get();
 555   EXPECT_EQ(V, MDNode::replaceWithPermanent(std::move(Temp2)));
 556   EXPECT_TRUE(V->isUniqued());
 557   EXPECT_EQ(U, V->getOperand(0));
 558 }
 559
 560 TEST_F(MDNodeTest, deleteTemporaryWithTrackingRef) {
 561   TrackingMDRef Ref;
 562   EXPECT_EQ(nullptr, Ref.get());
 563   {
 564     auto Temp = MDTuple::getTemporary(Context, None);
 565     Ref.reset(Temp.get());
 566     EXPECT_EQ(Temp.get(), Ref.get());
 567   }
 568   EXPECT_EQ(nullptr, Ref.get());
 569 }
 570
 571 typedef MetadataTest MDLocationTest;
 572
 573 TEST_F(MDLocationTest, Overflow) {
 574   MDNode *N = MDNode::get(Context, None);
 575   {
 576     MDLocation *L = MDLocation::get(Context, 2, 7, N);
 577     EXPECT_EQ(2u, L->getLine());
 578     EXPECT_EQ(7u, L->getColumn());
 579   }
 580   unsigned U16 = 1u << 16;
 581   {
 582     MDLocation *L = MDLocation::get(Context, UINT32_MAX, U16 - 1, N);
 583     EXPECT_EQ(UINT32_MAX, L->getLine());
 584     EXPECT_EQ(U16 - 1, L->getColumn());
 585   }
 586   {
 587     MDLocation *L = MDLocation::get(Context, UINT32_MAX, U16, N);
 588     EXPECT_EQ(UINT32_MAX, L->getLine());
 589     EXPECT_EQ(0u, L->getColumn());
 590   }
 591   {
 592     MDLocation *L = MDLocation::get(Context, UINT32_MAX, U16 + 1, N);
 593     EXPECT_EQ(UINT32_MAX, L->getLine());
 594     EXPECT_EQ(0u, L->getColumn());
 595   }
 596 }
 597
 598 TEST_F(MDLocationTest, getDistinct) {
 599   MDNode *N = MDNode::get(Context, None);
 600   MDLocation *L0 = MDLocation::getDistinct(Context, 2, 7, N);
 601   EXPECT_TRUE(L0->isDistinct());
 602   MDLocation *L1 = MDLocation::get(Context, 2, 7, N);
 603   EXPECT_FALSE(L1->isDistinct());
 604   EXPECT_EQ(L1, MDLocation::get(Context, 2, 7, N));
 605 }
 606
 607 TEST_F(MDLocationTest, getTemporary) {
 608   MDNode *N = MDNode::get(Context, None);
 609   auto L = MDLocation::getTemporary(Context, 2, 7, N);
 610   EXPECT_TRUE(L->isTemporary());
 611   EXPECT_FALSE(L->isResolved());
 612 }
 613
 614 typedef MetadataTest GenericDebugNodeTest;
 615
 616 TEST_F(GenericDebugNodeTest, get) {
 617   StringRef Header = "header";
 618   auto *Empty = MDNode::get(Context, None);
 619   Metadata *Ops1[] = {Empty};
 620   auto *N = GenericDebugNode::get(Context, 15, Header, Ops1);
 621   EXPECT_EQ(15u, N->getTag());
 622   EXPECT_EQ(2u, N->getNumOperands());
 623   EXPECT_EQ(Header, N->getHeader());
 624   EXPECT_EQ(MDString::get(Context, Header), N->getOperand(0));
 625   EXPECT_EQ(1u, N->getNumDwarfOperands());
 626   EXPECT_EQ(Empty, N->getDwarfOperand(0));
 627   EXPECT_EQ(Empty, N->getOperand(1));
 628   ASSERT_TRUE(N->isUniqued());
 629
 630   EXPECT_EQ(N, GenericDebugNode::get(Context, 15, Header, Ops1));
 631
 632   N->replaceOperandWith(1, nullptr);
 633   EXPECT_EQ(15u, N->getTag());
 634   EXPECT_EQ(Header, N->getHeader());
 635   EXPECT_EQ(nullptr, N->getDwarfOperand(0));
 636   ASSERT_TRUE(N->isUniqued());
 637
 638   Metadata *Ops2[] = {nullptr};
 639   EXPECT_EQ(N, GenericDebugNode::get(Context, 15, Header, Ops2));
 640
 641   N->replaceDwarfOperandWith(0, Empty);
 642   EXPECT_EQ(15u, N->getTag());
 643   EXPECT_EQ(Header, N->getHeader());
 644   EXPECT_EQ(Empty, N->getDwarfOperand(0));
 645   ASSERT_TRUE(N->isUniqued());
 646   EXPECT_EQ(N, GenericDebugNode::get(Context, 15, Header, Ops1));
 647
 648   TempGenericDebugNode Temp = N->clone();
 649   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 650 }
 651
 652 TEST_F(GenericDebugNodeTest, getEmptyHeader) {
 653   // Canonicalize !"" to null.
 654   auto *N = GenericDebugNode::get(Context, 15, StringRef(), None);
 655   EXPECT_EQ(StringRef(), N->getHeader());
 656   EXPECT_EQ(nullptr, N->getOperand(0));
 657 }
 658
 659 typedef MetadataTest MDSubrangeTest;
 660
 661 TEST_F(MDSubrangeTest, get) {
 662   auto *N = MDSubrange::get(Context, 5, 7);
 663   EXPECT_EQ(dwarf::DW_TAG_subrange_type, N->getTag());
 664   EXPECT_EQ(5, N->getCount());
 665   EXPECT_EQ(7, N->getLo());
 666   EXPECT_EQ(N, MDSubrange::get(Context, 5, 7));
 667   EXPECT_EQ(MDSubrange::get(Context, 5, 0), MDSubrange::get(Context, 5));
 668
 669   TempMDSubrange Temp = N->clone();
 670   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 671 }
 672
 673 typedef MetadataTest MDEnumeratorTest;
 674
 675 TEST_F(MDEnumeratorTest, get) {
 676   auto *N = MDEnumerator::get(Context, 7, "name");
 677   EXPECT_EQ(dwarf::DW_TAG_enumerator, N->getTag());
 678   EXPECT_EQ(7, N->getValue());
 679   EXPECT_EQ("name", N->getName());
 680   EXPECT_EQ(N, MDEnumerator::get(Context, 7, "name"));
 681
 682   EXPECT_NE(N, MDEnumerator::get(Context, 8, "name"));
 683   EXPECT_NE(N, MDEnumerator::get(Context, 7, "nam"));
 684
 685   TempMDEnumerator Temp = N->clone();
 686   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 687 }
 688
 689 typedef MetadataTest MDBasicTypeTest;
 690
 691 TEST_F(MDBasicTypeTest, get) {
 692   auto *N =
 693       MDBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33, 26, 7);
 694   EXPECT_EQ(dwarf::DW_TAG_base_type, N->getTag());
 695   EXPECT_EQ("special", N->getName());
 696   EXPECT_EQ(33u, N->getSizeInBits());
 697   EXPECT_EQ(26u, N->getAlignInBits());
 698   EXPECT_EQ(7u, N->getEncoding());
 699   EXPECT_EQ(0u, N->getLine());
 700   EXPECT_EQ(N, MDBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
 701                                 26, 7));
 702
 703   EXPECT_NE(N, MDBasicType::get(Context, dwarf::DW_TAG_unspecified_type,
 704                                 "special", 33, 26, 7));
 705   EXPECT_NE(N,
 706             MDBasicType::get(Context, dwarf::DW_TAG_base_type, "s", 33, 26, 7));
 707   EXPECT_NE(N, MDBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 32,
 708                                 26, 7));
 709   EXPECT_NE(N, MDBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
 710                                 25, 7));
 711   EXPECT_NE(N, MDBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
 712                                 26, 6));
 713
 714   TempMDBasicType Temp = N->clone();
 715   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 716 }
 717
 718 typedef MetadataTest MDDerivedTypeTest;
 719
 720 TEST_F(MDDerivedTypeTest, get) {
 721   Metadata *File = MDTuple::getDistinct(Context, None);
 722   Metadata *Scope = MDTuple::getDistinct(Context, None);
 723   Metadata *BaseType = MDTuple::getDistinct(Context, None);
 724   Metadata *ExtraData = MDTuple::getDistinct(Context, None);
 725
 726   auto *N = MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",
 727                                File, 1, Scope, BaseType, 2, 3, 4, 5, ExtraData);
 728   EXPECT_EQ(dwarf::DW_TAG_pointer_type, N->getTag());
 729   EXPECT_EQ("something", N->getName());
 730   EXPECT_EQ(File, N->getFile());
 731   EXPECT_EQ(1u, N->getLine());
 732   EXPECT_EQ(Scope, N->getScope());
 733   EXPECT_EQ(BaseType, N->getBaseType());
 734   EXPECT_EQ(2u, N->getSizeInBits());
 735   EXPECT_EQ(3u, N->getAlignInBits());
 736   EXPECT_EQ(4u, N->getOffsetInBits());
 737   EXPECT_EQ(5u, N->getFlags());
 738   EXPECT_EQ(ExtraData, N->getExtraData());
 739   EXPECT_EQ(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
 740                                   "something", File, 1, Scope, BaseType, 2, 3,
 741                                   4, 5, ExtraData));
 742
 743   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_reference_type,
 744                                   "something", File, 1, Scope, BaseType, 2, 3,
 745                                   4, 5, ExtraData));
 746   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "else",
 747                                   File, 1, Scope, BaseType, 2, 3, 4, 5,
 748                                   ExtraData));
 749   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
 750                                   "something", Scope, 1, Scope, BaseType, 2, 3,
 751                                   4, 5, ExtraData));
 752   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
 753                                   "something", File, 2, Scope, BaseType, 2, 3,
 754                                   4, 5, ExtraData));
 755   EXPECT_NE(N,
 756             MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",
 757                                File, 1, File, BaseType, 2, 3, 4, 5, ExtraData));
 758   EXPECT_NE(N,
 759             MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",
 760                                File, 1, Scope, File, 2, 3, 4, 5, ExtraData));
 761   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
 762                                   "something", File, 1, Scope, BaseType, 3, 3,
 763                                   4, 5, ExtraData));
 764   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
 765                                   "something", File, 1, Scope, BaseType, 2, 2,
 766                                   4, 5, ExtraData));
 767   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
 768                                   "something", File, 1, Scope, BaseType, 2, 3,
 769                                   5, 5, ExtraData));
 770   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
 771                                   "something", File, 1, Scope, BaseType, 2, 3,
 772                                   4, 4, ExtraData));
 773   EXPECT_NE(N,
 774             MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",
 775                                File, 1, Scope, BaseType, 2, 3, 4, 5, File));
 776
 777   TempMDDerivedType Temp = N->clone();
 778   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 779 }
 780
 781 typedef MetadataTest MDCompositeTypeTest;
 782
 783 TEST_F(MDCompositeTypeTest, get) {
 784   unsigned Tag = dwarf::DW_TAG_structure_type;
 785   StringRef Name = "some name";
 786   Metadata *File = MDTuple::getDistinct(Context, None);
 787   unsigned Line = 1;
 788   Metadata *Scope = MDTuple::getDistinct(Context, None);
 789   Metadata *BaseType = MDTuple::getDistinct(Context, None);
 790   unsigned SizeInBits = 2;
 791   unsigned AlignInBits = 3;
 792   unsigned OffsetInBits = 4;
 793   unsigned Flags = 5;
 794   Metadata *Elements = MDTuple::getDistinct(Context, None);
 795   unsigned RuntimeLang = 6;
 796   Metadata *VTableHolder = MDTuple::getDistinct(Context, None);
 797   Metadata *TemplateParams = MDTuple::getDistinct(Context, None);
 798   StringRef Identifier = "some id";
 799
 800   auto *N = MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 801                                  BaseType, SizeInBits, AlignInBits,
 802                                  OffsetInBits, Flags, Elements, RuntimeLang,
 803                                  VTableHolder, TemplateParams, Identifier);
 804   EXPECT_EQ(Tag, N->getTag());
 805   EXPECT_EQ(Name, N->getName());
 806   EXPECT_EQ(File, N->getFile());
 807   EXPECT_EQ(Line, N->getLine());
 808   EXPECT_EQ(Scope, N->getScope());
 809   EXPECT_EQ(BaseType, N->getBaseType());
 810   EXPECT_EQ(SizeInBits, N->getSizeInBits());
 811   EXPECT_EQ(AlignInBits, N->getAlignInBits());
 812   EXPECT_EQ(OffsetInBits, N->getOffsetInBits());
 813   EXPECT_EQ(Flags, N->getFlags());
 814   EXPECT_EQ(Elements, N->getElements());
 815   EXPECT_EQ(RuntimeLang, N->getRuntimeLang());
 816   EXPECT_EQ(VTableHolder, N->getVTableHolder());
 817   EXPECT_EQ(TemplateParams, N->getTemplateParams());
 818   EXPECT_EQ(Identifier, N->getIdentifier());
 819
 820   EXPECT_EQ(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 821                                     BaseType, SizeInBits, AlignInBits,
 822                                     OffsetInBits, Flags, Elements, RuntimeLang,
 823                                     VTableHolder, TemplateParams, Identifier));
 824
 825   EXPECT_NE(N, MDCompositeType::get(Context, Tag + 1, Name, File, Line, Scope,
 826                                     BaseType, SizeInBits, AlignInBits,
 827                                     OffsetInBits, Flags, Elements, RuntimeLang,
 828                                     VTableHolder, TemplateParams, Identifier));
 829   EXPECT_NE(N, MDCompositeType::get(Context, Tag, "abc", File, Line, Scope,
 830                                     BaseType, SizeInBits, AlignInBits,
 831                                     OffsetInBits, Flags, Elements, RuntimeLang,
 832                                     VTableHolder, TemplateParams, Identifier));
 833   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, Scope, Line, Scope,
 834                                     BaseType, SizeInBits, AlignInBits,
 835                                     OffsetInBits, Flags, Elements, RuntimeLang,
 836                                     VTableHolder, TemplateParams, Identifier));
 837   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line + 1, Scope,
 838                                     BaseType, SizeInBits, AlignInBits,
 839                                     OffsetInBits, Flags, Elements, RuntimeLang,
 840                                     VTableHolder, TemplateParams, Identifier));
 841   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, File,
 842                                     BaseType, SizeInBits, AlignInBits,
 843                                     OffsetInBits, Flags, Elements, RuntimeLang,
 844                                     VTableHolder, TemplateParams, Identifier));
 845   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope, File,
 846                                     SizeInBits, AlignInBits, OffsetInBits,
 847                                     Flags, Elements, RuntimeLang, VTableHolder,
 848                                     TemplateParams, Identifier));
 849   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 850                                     BaseType, SizeInBits + 1, AlignInBits,
 851                                     OffsetInBits, Flags, Elements, RuntimeLang,
 852                                     VTableHolder, TemplateParams, Identifier));
 853   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 854                                     BaseType, SizeInBits, AlignInBits + 1,
 855                                     OffsetInBits, Flags, Elements, RuntimeLang,
 856                                     VTableHolder, TemplateParams, Identifier));
 857   EXPECT_NE(N, MDCompositeType::get(
 858                    Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
 859                    AlignInBits, OffsetInBits + 1, Flags, Elements, RuntimeLang,
 860                    VTableHolder, TemplateParams, Identifier));
 861   EXPECT_NE(N, MDCompositeType::get(
 862                    Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
 863                    AlignInBits, OffsetInBits, Flags + 1, Elements, RuntimeLang,
 864                    VTableHolder, TemplateParams, Identifier));
 865   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 866                                     BaseType, SizeInBits, AlignInBits,
 867                                     OffsetInBits, Flags, File, RuntimeLang,
 868                                     VTableHolder, TemplateParams, Identifier));
 869   EXPECT_NE(N, MDCompositeType::get(
 870                    Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
 871                    AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang + 1,
 872                    VTableHolder, TemplateParams, Identifier));
 873   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 874                                     BaseType, SizeInBits, AlignInBits,
 875                                     OffsetInBits, Flags, Elements, RuntimeLang,
 876                                     File, TemplateParams, Identifier));
 877   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 878                                     BaseType, SizeInBits, AlignInBits,
 879                                     OffsetInBits, Flags, Elements, RuntimeLang,
 880                                     VTableHolder, File, Identifier));
 881   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 882                                     BaseType, SizeInBits, AlignInBits,
 883                                     OffsetInBits, Flags, Elements, RuntimeLang,
 884                                     VTableHolder, TemplateParams, "other"));
 885
 886   // Be sure that missing identifiers get null pointers.
 887   EXPECT_FALSE(MDCompositeType::get(
 888                    Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
 889                    AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
 890                    VTableHolder, TemplateParams, "")->getRawIdentifier());
 891   EXPECT_FALSE(MDCompositeType::get(
 892                    Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
 893                    AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
 894                    VTableHolder, TemplateParams)->getRawIdentifier());
 895
 896   TempMDCompositeType Temp = N->clone();
 897   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 898 }
 899
 900 typedef MetadataTest MDSubroutineTypeTest;
 901
 902 TEST_F(MDSubroutineTypeTest, get) {
 903   unsigned Flags = 1;
 904   Metadata *TypeArray = MDTuple::getDistinct(Context, None);
 905
 906   auto *N = MDSubroutineType::get(Context, Flags, TypeArray);
 907   EXPECT_EQ(dwarf::DW_TAG_subroutine_type, N->getTag());
 908   EXPECT_EQ(Flags, N->getFlags());
 909   EXPECT_EQ(TypeArray, N->getTypeArray());
 910   EXPECT_EQ(N, MDSubroutineType::get(Context, Flags, TypeArray));
 911
 912   EXPECT_NE(N, MDSubroutineType::get(Context, Flags + 1, TypeArray));
 913   EXPECT_NE(N, MDSubroutineType::get(Context, Flags,
 914                                      MDTuple::getDistinct(Context, None)));
 915
 916   TempMDSubroutineType Temp = N->clone();
 917   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 918 }
 919
 920 typedef MetadataTest MDFileTest;
 921
 922 TEST_F(MDFileTest, get) {
 923   StringRef Filename = "file";
 924   StringRef Directory = "dir";
 925   auto *N = MDFile::get(Context, Filename, Directory);
 926
 927   EXPECT_EQ(dwarf::DW_TAG_file_type, N->getTag());
 928   EXPECT_EQ(Filename, N->getFilename());
 929   EXPECT_EQ(Directory, N->getDirectory());
 930   EXPECT_EQ(N, MDFile::get(Context, Filename, Directory));
 931
 932   EXPECT_NE(N, MDFile::get(Context, "other", Directory));
 933   EXPECT_NE(N, MDFile::get(Context, Filename, "other"));
 934
 935   TempMDFile Temp = N->clone();
 936   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 937 }
 938
 939 typedef MetadataTest MDCompileUnitTest;
 940
 941 TEST_F(MDCompileUnitTest, get) {
 942   unsigned SourceLanguage = 1;
 943   Metadata *File = MDTuple::getDistinct(Context, None);
 944   StringRef Producer = "some producer";
 945   bool IsOptimized = false;
 946   StringRef Flags = "flag after flag";
 947   unsigned RuntimeVersion = 2;
 948   StringRef SplitDebugFilename = "another/file";
 949   unsigned EmissionKind = 3;
 950   Metadata *EnumTypes = MDTuple::getDistinct(Context, None);
 951   Metadata *RetainedTypes = MDTuple::getDistinct(Context, None);
 952   Metadata *Subprograms = MDTuple::getDistinct(Context, None);
 953   Metadata *GlobalVariables = MDTuple::getDistinct(Context, None);
 954   Metadata *ImportedEntities = MDTuple::getDistinct(Context, None);
 955   auto *N = MDCompileUnit::get(
 956       Context, SourceLanguage, File, Producer, IsOptimized, Flags,
 957       RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
 958       RetainedTypes, Subprograms, GlobalVariables, ImportedEntities);
 959
 960   EXPECT_EQ(dwarf::DW_TAG_compile_unit, N->getTag());
 961   EXPECT_EQ(SourceLanguage, N->getSourceLanguage());
 962   EXPECT_EQ(File, N->getFile());
 963   EXPECT_EQ(Producer, N->getProducer());
 964   EXPECT_EQ(IsOptimized, N->isOptimized());
 965   EXPECT_EQ(Flags, N->getFlags());
 966   EXPECT_EQ(RuntimeVersion, N->getRuntimeVersion());
 967   EXPECT_EQ(SplitDebugFilename, N->getSplitDebugFilename());
 968   EXPECT_EQ(EmissionKind, N->getEmissionKind());
 969   EXPECT_EQ(EnumTypes, N->getEnumTypes());
 970   EXPECT_EQ(RetainedTypes, N->getRetainedTypes());
 971   EXPECT_EQ(Subprograms, N->getSubprograms());
 972   EXPECT_EQ(GlobalVariables, N->getGlobalVariables());
 973   EXPECT_EQ(ImportedEntities, N->getImportedEntities());
 974   EXPECT_EQ(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
 975                                   IsOptimized, Flags, RuntimeVersion,
 976                                   SplitDebugFilename, EmissionKind, EnumTypes,
 977                                   RetainedTypes, Subprograms, GlobalVariables,
 978                                   ImportedEntities));
 979
 980   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage + 1, File, Producer,
 981                                   IsOptimized, Flags, RuntimeVersion,
 982                                   SplitDebugFilename, EmissionKind, EnumTypes,
 983                                   RetainedTypes, Subprograms, GlobalVariables,
 984                                   ImportedEntities));
 985   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, EnumTypes, Producer,
 986                                   IsOptimized, Flags, RuntimeVersion,
 987                                   SplitDebugFilename, EmissionKind, EnumTypes,
 988                                   RetainedTypes, Subprograms, GlobalVariables,
 989                                   ImportedEntities));
 990   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, "other",
 991                                   IsOptimized, Flags, RuntimeVersion,
 992                                   SplitDebugFilename, EmissionKind, EnumTypes,
 993                                   RetainedTypes, Subprograms, GlobalVariables,
 994                                   ImportedEntities));
 995   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
 996                                   !IsOptimized, Flags, RuntimeVersion,
 997                                   SplitDebugFilename, EmissionKind, EnumTypes,
 998                                   RetainedTypes, Subprograms, GlobalVariables,
 999                                   ImportedEntities));
1000   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
1001                                   IsOptimized, "other", RuntimeVersion,
1002                                   SplitDebugFilename, EmissionKind, EnumTypes,
1003                                   RetainedTypes, Subprograms, GlobalVariables,
1004                                   ImportedEntities));
1005   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
1006                                   IsOptimized, Flags, RuntimeVersion + 1,
1007                                   SplitDebugFilename, EmissionKind, EnumTypes,
1008                                   RetainedTypes, Subprograms, GlobalVariables,
1009                                   ImportedEntities));
1010   EXPECT_NE(N,
1011             MDCompileUnit::get(Context, SourceLanguage, File, Producer,
1012                                IsOptimized, Flags, RuntimeVersion, "other",
1013                                EmissionKind, EnumTypes, RetainedTypes,
1014                                Subprograms, GlobalVariables, ImportedEntities));
1015   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
1016                                   IsOptimized, Flags, RuntimeVersion,
1017                                   SplitDebugFilename, EmissionKind + 1,
1018                                   EnumTypes, RetainedTypes, Subprograms,
1019                                   GlobalVariables, ImportedEntities));
1020   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
1021                                   IsOptimized, Flags, RuntimeVersion,
1022                                   SplitDebugFilename, EmissionKind, File,
1023                                   RetainedTypes, Subprograms, GlobalVariables,
1024                                   ImportedEntities));
1025   EXPECT_NE(N, MDCompileUnit::get(
1026                    Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1027                    RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1028                    File, Subprograms, GlobalVariables, ImportedEntities));
1029   EXPECT_NE(N, MDCompileUnit::get(
1030                    Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1031                    RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1032                    RetainedTypes, File, GlobalVariables, ImportedEntities));
1033   EXPECT_NE(N, MDCompileUnit::get(
1034                    Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1035                    RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1036                    RetainedTypes, Subprograms, File, ImportedEntities));
1037   EXPECT_NE(N, MDCompileUnit::get(
1038                    Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1039                    RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1040                    RetainedTypes, Subprograms, GlobalVariables, File));
1041
1042   TempMDCompileUnit Temp = N->clone();
1043   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1044 }
1045
1046 typedef MetadataTest MDSubprogramTest;
1047
1048 TEST_F(MDSubprogramTest, get) {
1049   Metadata *Scope = MDTuple::getDistinct(Context, None);
1050   StringRef Name = "name";
1051   StringRef LinkageName = "linkage";
1052   Metadata *File = MDTuple::getDistinct(Context, None);
1053   unsigned Line = 2;
1054   Metadata *Type = MDTuple::getDistinct(Context, None);
1055   bool IsLocalToUnit = false;
1056   bool IsDefinition = true;
1057   unsigned ScopeLine = 3;
1058   Metadata *ContainingType = MDTuple::getDistinct(Context, None);
1059   unsigned Virtuality = 4;
1060   unsigned VirtualIndex = 5;
1061   unsigned Flags = 6;
1062   bool IsOptimized = false;
1063   Metadata *Function = MDTuple::getDistinct(Context, None);
1064   Metadata *TemplateParams = MDTuple::getDistinct(Context, None);
1065   Metadata *Declaration = MDTuple::getDistinct(Context, None);
1066   Metadata *Variables = MDTuple::getDistinct(Context, None);
1067
1068   auto *N = MDSubprogram::get(
1069       Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1070       IsDefinition, ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags,
1071       IsOptimized, Function, TemplateParams, Declaration, Variables);
1072
1073   EXPECT_EQ(dwarf::DW_TAG_subprogram, N->getTag());
1074   EXPECT_EQ(Scope, N->getScope());
1075   EXPECT_EQ(Name, N->getName());
1076   EXPECT_EQ(LinkageName, N->getLinkageName());
1077   EXPECT_EQ(File, N->getFile());
1078   EXPECT_EQ(Line, N->getLine());
1079   EXPECT_EQ(Type, N->getType());
1080   EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());
1081   EXPECT_EQ(IsDefinition, N->isDefinition());
1082   EXPECT_EQ(ScopeLine, N->getScopeLine());
1083   EXPECT_EQ(ContainingType, N->getContainingType());
1084   EXPECT_EQ(Virtuality, N->getVirtuality());
1085   EXPECT_EQ(VirtualIndex, N->getVirtualIndex());
1086   EXPECT_EQ(Flags, N->getFlags());
1087   EXPECT_EQ(IsOptimized, N->isOptimized());
1088   EXPECT_EQ(Function, N->getFunction());
1089   EXPECT_EQ(TemplateParams, N->getTemplateParams());
1090   EXPECT_EQ(Declaration, N->getDeclaration());
1091   EXPECT_EQ(Variables, N->getVariables());
1092   EXPECT_EQ(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1093                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1094                                  ContainingType, Virtuality, VirtualIndex,
1095                                  Flags, IsOptimized, Function, TemplateParams,
1096                                  Declaration, Variables));
1097
1098   EXPECT_NE(N, MDSubprogram::get(Context, File, Name, LinkageName, File, Line,
1099                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1100                                  ContainingType, Virtuality, VirtualIndex,
1101                                  Flags, IsOptimized, Function, TemplateParams,
1102                                  Declaration, Variables));
1103   EXPECT_NE(N, MDSubprogram::get(Context, Scope, "other", LinkageName, File,
1104                                  Line, Type, IsLocalToUnit, IsDefinition,
1105                                  ScopeLine, ContainingType, Virtuality,
1106                                  VirtualIndex, Flags, IsOptimized, Function,
1107                                  TemplateParams, Declaration, Variables));
1108   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, "other", File, Line,
1109                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1110                                  ContainingType, Virtuality, VirtualIndex,
1111                                  Flags, IsOptimized, Function, TemplateParams,
1112                                  Declaration, Variables));
1113   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, Scope, Line,
1114                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1115                                  ContainingType, Virtuality, VirtualIndex,
1116                                  Flags, IsOptimized, Function, TemplateParams,
1117                                  Declaration, Variables));
1118   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File,
1119                                  Line + 1, Type, IsLocalToUnit, IsDefinition,
1120                                  ScopeLine, ContainingType, Virtuality,
1121                                  VirtualIndex, Flags, IsOptimized, Function,
1122                                  TemplateParams, Declaration, Variables));
1123   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1124                                  Scope, IsLocalToUnit, IsDefinition, ScopeLine,
1125                                  ContainingType, Virtuality, VirtualIndex,
1126                                  Flags, IsOptimized, Function, TemplateParams,
1127                                  Declaration, Variables));
1128   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1129                                  Type, !IsLocalToUnit, IsDefinition, ScopeLine,
1130                                  ContainingType, Virtuality, VirtualIndex,
1131                                  Flags, IsOptimized, Function, TemplateParams,
1132                                  Declaration, Variables));
1133   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1134                                  Type, IsLocalToUnit, !IsDefinition, ScopeLine,
1135                                  ContainingType, Virtuality, VirtualIndex,
1136                                  Flags, IsOptimized, Function, TemplateParams,
1137                                  Declaration, Variables));
1138   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1139                                  Type, IsLocalToUnit, IsDefinition,
1140                                  ScopeLine + 1, ContainingType, Virtuality,
1141                                  VirtualIndex, Flags, IsOptimized, Function,
1142                                  TemplateParams, Declaration, Variables));
1143   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1144                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1145                                  Type, Virtuality, VirtualIndex, Flags,
1146                                  IsOptimized, Function, TemplateParams,
1147                                  Declaration, Variables));
1148   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1149                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1150                                  ContainingType, Virtuality + 1, VirtualIndex,
1151                                  Flags, IsOptimized, Function, TemplateParams,
1152                                  Declaration, Variables));
1153   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1154                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1155                                  ContainingType, Virtuality, VirtualIndex + 1,
1156                                  Flags, IsOptimized, Function, TemplateParams,
1157                                  Declaration, Variables));
1158   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1159                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1160                                  ContainingType, Virtuality, VirtualIndex,
1161                                  ~Flags, IsOptimized, Function, TemplateParams,
1162                                  Declaration, Variables));
1163   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1164                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1165                                  ContainingType, Virtuality, VirtualIndex,
1166                                  Flags, !IsOptimized, Function, TemplateParams,
1167                                  Declaration, Variables));
1168   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1169                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1170                                  ContainingType, Virtuality, VirtualIndex,
1171                                  Flags, IsOptimized, Type, TemplateParams,
1172                                  Declaration, Variables));
1173   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1174                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1175                                  ContainingType, Virtuality, VirtualIndex,
1176                                  Flags, IsOptimized, Function, Type,
1177                                  Declaration, Variables));
1178   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1179                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1180                                  ContainingType, Virtuality, VirtualIndex,
1181                                  Flags, IsOptimized, Function, TemplateParams,
1182                                  Type, Variables));
1183   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1184                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1185                                  ContainingType, Virtuality, VirtualIndex,
1186                                  Flags, IsOptimized, Function, TemplateParams,
1187                                  Declaration, Type));
1188
1189   TempMDSubprogram Temp = N->clone();
1190   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1191 }
1192
1193 TEST_F(MDSubprogramTest, replaceFunction) {
1194   Metadata *Scope = MDTuple::getDistinct(Context, None);
1195   StringRef Name = "name";
1196   StringRef LinkageName = "linkage";
1197   Metadata *File = MDTuple::getDistinct(Context, None);
1198   unsigned Line = 2;
1199   Metadata *Type = MDTuple::getDistinct(Context, None);
1200   bool IsLocalToUnit = false;
1201   bool IsDefinition = true;
1202   unsigned ScopeLine = 3;
1203   Metadata *ContainingType = MDTuple::getDistinct(Context, None);
1204   unsigned Virtuality = 4;
1205   unsigned VirtualIndex = 5;
1206   unsigned Flags = 6;
1207   bool IsOptimized = false;
1208   Metadata *TemplateParams = MDTuple::getDistinct(Context, None);
1209   Metadata *Declaration = MDTuple::getDistinct(Context, None);
1210   Metadata *Variables = MDTuple::getDistinct(Context, None);
1211
1212   auto *N = MDSubprogram::get(
1213       Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1214       IsDefinition, ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags,
1215       IsOptimized, nullptr, TemplateParams, Declaration, Variables);
1216
1217   EXPECT_EQ(nullptr, N->getFunction());
1218
1219   std::unique_ptr<Function> F(
1220       Function::Create(FunctionType::get(Type::getVoidTy(Context), false),
1221                        GlobalValue::ExternalLinkage));
1222   N->replaceFunction(F.get());
1223   EXPECT_EQ(ConstantAsMetadata::get(F.get()), N->getFunction());
1224
1225   N->replaceFunction(nullptr);
1226   EXPECT_EQ(nullptr, N->getFunction());
1227 }
1228
1229 typedef MetadataTest MDLexicalBlockTest;
1230
1231 TEST_F(MDLexicalBlockTest, get) {
1232   Metadata *Scope = MDTuple::getDistinct(Context, None);
1233   Metadata *File = MDTuple::getDistinct(Context, None);
1234   unsigned Line = 5;
1235   unsigned Column = 8;
1236
1237   auto *N = MDLexicalBlock::get(Context, Scope, File, Line, Column);
1238
1239   EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());
1240   EXPECT_EQ(Scope, N->getScope());
1241   EXPECT_EQ(File, N->getFile());
1242   EXPECT_EQ(Line, N->getLine());
1243   EXPECT_EQ(Column, N->getColumn());
1244   EXPECT_EQ(N, MDLexicalBlock::get(Context, Scope, File, Line, Column));
1245
1246   EXPECT_NE(N, MDLexicalBlock::get(Context, File, File, Line, Column));
1247   EXPECT_NE(N, MDLexicalBlock::get(Context, Scope, Scope, Line, Column));
1248   EXPECT_NE(N, MDLexicalBlock::get(Context, Scope, File, Line + 1, Column));
1249   EXPECT_NE(N, MDLexicalBlock::get(Context, Scope, File, Line, Column + 1));
1250
1251   TempMDLexicalBlock Temp = N->clone();
1252   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1253 }
1254
1255 typedef MetadataTest MDLexicalBlockFileTest;
1256
1257 TEST_F(MDLexicalBlockFileTest, get) {
1258   Metadata *Scope = MDTuple::getDistinct(Context, None);
1259   Metadata *File = MDTuple::getDistinct(Context, None);
1260   unsigned Discriminator = 5;
1261
1262   auto *N = MDLexicalBlockFile::get(Context, Scope, File, Discriminator);
1263
1264   EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());
1265   EXPECT_EQ(Scope, N->getScope());
1266   EXPECT_EQ(File, N->getFile());
1267   EXPECT_EQ(Discriminator, N->getDiscriminator());
1268   EXPECT_EQ(N, MDLexicalBlockFile::get(Context, Scope, File, Discriminator));
1269
1270   EXPECT_NE(N, MDLexicalBlockFile::get(Context, File, File, Discriminator));
1271   EXPECT_NE(N, MDLexicalBlockFile::get(Context, Scope, Scope, Discriminator));
1272   EXPECT_NE(N,
1273             MDLexicalBlockFile::get(Context, Scope, File, Discriminator + 1));
1274
1275   TempMDLexicalBlockFile Temp = N->clone();
1276   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1277 }
1278
1279 typedef MetadataTest MDNamespaceTest;
1280
1281 TEST_F(MDNamespaceTest, get) {
1282   Metadata *Scope = MDTuple::getDistinct(Context, None);
1283   Metadata *File = MDTuple::getDistinct(Context, None);
1284   StringRef Name = "namespace";
1285   unsigned Line = 5;
1286
1287   auto *N = MDNamespace::get(Context, Scope, File, Name, Line);
1288
1289   EXPECT_EQ(dwarf::DW_TAG_namespace, N->getTag());
1290   EXPECT_EQ(Scope, N->getScope());
1291   EXPECT_EQ(File, N->getFile());
1292   EXPECT_EQ(Name, N->getName());
1293   EXPECT_EQ(Line, N->getLine());
1294   EXPECT_EQ(N, MDNamespace::get(Context, Scope, File, Name, Line));
1295
1296   EXPECT_NE(N, MDNamespace::get(Context, File, File, Name, Line));
1297   EXPECT_NE(N, MDNamespace::get(Context, Scope, Scope, Name, Line));
1298   EXPECT_NE(N, MDNamespace::get(Context, Scope, File, "other", Line));
1299   EXPECT_NE(N, MDNamespace::get(Context, Scope, File, Name, Line + 1));
1300
1301   TempMDNamespace Temp = N->clone();
1302   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1303 }
1304
1305 typedef MetadataTest MDTemplateTypeParameterTest;
1306
1307 TEST_F(MDTemplateTypeParameterTest, get) {
1308   Metadata *Scope = MDTuple::getDistinct(Context, None);
1309   StringRef Name = "template";
1310   Metadata *Type = MDTuple::getDistinct(Context, None);
1311
1312   auto *N = MDTemplateTypeParameter::get(Context, Scope, Name, Type);
1313
1314   EXPECT_EQ(dwarf::DW_TAG_template_type_parameter, N->getTag());
1315   EXPECT_EQ(Scope, N->getScope());
1316   EXPECT_EQ(Name, N->getName());
1317   EXPECT_EQ(Type, N->getType());
1318   EXPECT_EQ(N, MDTemplateTypeParameter::get(Context, Scope, Name, Type));
1319
1320   EXPECT_NE(N, MDTemplateTypeParameter::get(Context, Type, Name, Type));
1321   EXPECT_NE(N, MDTemplateTypeParameter::get(Context, Scope, "other", Type));
1322   EXPECT_NE(N, MDTemplateTypeParameter::get(Context, Scope, Name, Scope));
1323
1324   TempMDTemplateTypeParameter Temp = N->clone();
1325   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1326 }
1327
1328 typedef MetadataTest MDTemplateValueParameterTest;
1329
1330 TEST_F(MDTemplateValueParameterTest, get) {
1331   unsigned Tag = dwarf::DW_TAG_template_value_parameter;
1332   Metadata *Scope = MDTuple::getDistinct(Context, None);
1333   StringRef Name = "template";
1334   Metadata *Type = MDTuple::getDistinct(Context, None);
1335   Metadata *Value = MDTuple::getDistinct(Context, None);
1336
1337   auto *N =
1338       MDTemplateValueParameter::get(Context, Tag, Scope, Name, Type, Value);
1339   EXPECT_EQ(Tag, N->getTag());
1340   EXPECT_EQ(Scope, N->getScope());
1341   EXPECT_EQ(Name, N->getName());
1342   EXPECT_EQ(Type, N->getType());
1343   EXPECT_EQ(Value, N->getValue());
1344   EXPECT_EQ(
1345       N, MDTemplateValueParameter::get(Context, Tag, Scope, Name, Type, Value));
1346
1347   EXPECT_NE(N, MDTemplateValueParameter::get(
1348                    Context, dwarf::DW_TAG_GNU_template_template_param, Scope,
1349                    Name, Type, Value));
1350   EXPECT_NE(
1351       N, MDTemplateValueParameter::get(Context, Tag, Type, Name, Type, Value));
1352   EXPECT_NE(N, MDTemplateValueParameter::get(Context, Tag, Scope, "other", Type,
1353                                              Value));
1354   EXPECT_NE(N, MDTemplateValueParameter::get(Context, Tag, Scope, Name, Scope,
1355                                              Value));
1356   EXPECT_NE(
1357       N, MDTemplateValueParameter::get(Context, Tag, Scope, Name, Type, Scope));
1358
1359   TempMDTemplateValueParameter Temp = N->clone();
1360   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1361 }
1362
1363 typedef MetadataTest MDGlobalVariableTest;
1364
1365 TEST_F(MDGlobalVariableTest, get) {
1366   Metadata *Scope = MDTuple::getDistinct(Context, None);
1367   StringRef Name = "name";
1368   StringRef LinkageName = "linkage";
1369   Metadata *File = MDTuple::getDistinct(Context, None);
1370   unsigned Line = 5;
1371   Metadata *Type = MDTuple::getDistinct(Context, None);
1372   bool IsLocalToUnit = false;
1373   bool IsDefinition = true;
1374   Metadata *Variable = MDTuple::getDistinct(Context, None);
1375   Metadata *StaticDataMemberDeclaration = MDTuple::getDistinct(Context, None);
1376
1377   auto *N = MDGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,
1378                                   Type, IsLocalToUnit, IsDefinition, Variable,
1379                                   StaticDataMemberDeclaration);
1380   EXPECT_EQ(dwarf::DW_TAG_variable, N->getTag());
1381   EXPECT_EQ(Scope, N->getScope());
1382   EXPECT_EQ(Name, N->getName());
1383   EXPECT_EQ(LinkageName, N->getLinkageName());
1384   EXPECT_EQ(File, N->getFile());
1385   EXPECT_EQ(Line, N->getLine());
1386   EXPECT_EQ(Type, N->getType());
1387   EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());
1388   EXPECT_EQ(IsDefinition, N->isDefinition());
1389   EXPECT_EQ(Variable, N->getVariable());
1390   EXPECT_EQ(StaticDataMemberDeclaration, N->getStaticDataMemberDeclaration());
1391   EXPECT_EQ(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1392                                      Line, Type, IsLocalToUnit, IsDefinition,
1393                                      Variable, StaticDataMemberDeclaration));
1394
1395   EXPECT_NE(N, MDGlobalVariable::get(Context, File, Name, LinkageName, File,
1396                                      Line, Type, IsLocalToUnit, IsDefinition,
1397                                      Variable, StaticDataMemberDeclaration));
1398   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, "other", LinkageName, File,
1399                                      Line, Type, IsLocalToUnit, IsDefinition,
1400                                      Variable, StaticDataMemberDeclaration));
1401   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, "other", File, Line,
1402                                      Type, IsLocalToUnit, IsDefinition,
1403                                      Variable, StaticDataMemberDeclaration));
1404   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, Scope,
1405                                      Line, Type, IsLocalToUnit, IsDefinition,
1406                                      Variable, StaticDataMemberDeclaration));
1407   EXPECT_NE(N,
1408             MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1409                                   Line + 1, Type, IsLocalToUnit, IsDefinition,
1410                                   Variable, StaticDataMemberDeclaration));
1411   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1412                                      Line, Scope, IsLocalToUnit, IsDefinition,
1413                                      Variable, StaticDataMemberDeclaration));
1414   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1415                                      Line, Type, !IsLocalToUnit, IsDefinition,
1416                                      Variable, StaticDataMemberDeclaration));
1417   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1418                                      Line, Type, IsLocalToUnit, !IsDefinition,
1419                                      Variable, StaticDataMemberDeclaration));
1420   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1421                                      Line, Type, IsLocalToUnit, IsDefinition,
1422                                      Type, StaticDataMemberDeclaration));
1423   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1424                                      Line, Type, IsLocalToUnit, IsDefinition,
1425                                      Variable, Type));
1426
1427   TempMDGlobalVariable Temp = N->clone();
1428   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1429 }
1430
1431 typedef MetadataTest MDLocalVariableTest;
1432
1433 TEST_F(MDLocalVariableTest, get) {
1434   unsigned Tag = dwarf::DW_TAG_arg_variable;
1435   Metadata *Scope = MDTuple::getDistinct(Context, None);
1436   StringRef Name = "name";
1437   Metadata *File = MDTuple::getDistinct(Context, None);
1438   unsigned Line = 5;
1439   Metadata *Type = MDTuple::getDistinct(Context, None);
1440   unsigned Arg = 6;
1441   unsigned Flags = 7;
1442   Metadata *InlinedAt = MDTuple::getDistinct(Context, None);
1443
1444   auto *N = MDLocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
1445                                  Arg, Flags, InlinedAt);
1446   EXPECT_EQ(Tag, N->getTag());
1447   EXPECT_EQ(Scope, N->getScope());
1448   EXPECT_EQ(Name, N->getName());
1449   EXPECT_EQ(File, N->getFile());
1450   EXPECT_EQ(Line, N->getLine());
1451   EXPECT_EQ(Type, N->getType());
1452   EXPECT_EQ(Arg, N->getArg());
1453   EXPECT_EQ(Flags, N->getFlags());
1454   EXPECT_EQ(InlinedAt, N->getInlinedAt());
1455   EXPECT_EQ(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
1456                                     Arg, Flags, InlinedAt));
1457
1458   EXPECT_NE(N, MDLocalVariable::get(Context, dwarf::DW_TAG_auto_variable, Scope,
1459                                     Name, File, Line, Type, Arg, Flags,
1460                                     InlinedAt));
1461   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, File, Name, File, Line,
1462                                     Type, Arg, Flags, InlinedAt));
1463   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, "other", File, Line,
1464                                     Type, Arg, Flags, InlinedAt));
1465   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, Scope, Line,
1466                                     Type, Arg, Flags, InlinedAt));
1467   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line + 1,
1468                                     Type, Arg, Flags, InlinedAt));
1469   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line,
1470                                     Scope, Arg, Flags, InlinedAt));
1471   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
1472                                     Arg + 1, Flags, InlinedAt));
1473   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
1474                                     Arg, ~Flags, InlinedAt));
1475   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
1476                                     Arg, Flags, Scope));
1477
1478   TempMDLocalVariable Temp = N->clone();
1479   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1480 }
1481
1482 typedef MetadataTest MDExpressionTest;
1483
1484 TEST_F(MDExpressionTest, get) {
1485   uint64_t Elements[] = {2, 6, 9, 78, 0};
1486   auto *N = MDExpression::get(Context, Elements);
1487   EXPECT_EQ(makeArrayRef(Elements), N->getElements());
1488   EXPECT_EQ(N, MDExpression::get(Context, Elements));
1489
1490   EXPECT_EQ(5u, N->getNumElements());
1491   EXPECT_EQ(2u, N->getElement(0));
1492   EXPECT_EQ(6u, N->getElement(1));
1493   EXPECT_EQ(9u, N->getElement(2));
1494   EXPECT_EQ(78u, N->getElement(3));
1495   EXPECT_EQ(0u, N->getElement(4));
1496
1497   TempMDExpression Temp = N->clone();
1498   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1499 }
1500
1501 TEST_F(MDExpressionTest, isValid) {
1502 #define EXPECT_VALID(...)                                                      \
1503   do {                                                                         \
1504     uint64_t Elements[] = {__VA_ARGS__};                                       \
1505     EXPECT_TRUE(MDExpression::get(Context, Elements)->isValid());              \
1506   } while (false)
1507 #define EXPECT_INVALID(...)                                                    \
1508   do {                                                                         \
1509     uint64_t Elements[] = {__VA_ARGS__};                                       \
1510     EXPECT_FALSE(MDExpression::get(Context, Elements)->isValid());             \
1511   } while (false)
1512
1513   // Empty expression should be valid.
1514   EXPECT_TRUE(MDExpression::get(Context, None));
1515
1516   // Valid constructions.
1517   EXPECT_VALID(dwarf::DW_OP_plus, 6);
1518   EXPECT_VALID(dwarf::DW_OP_deref);
1519   EXPECT_VALID(dwarf::DW_OP_bit_piece, 3, 7);
1520   EXPECT_VALID(dwarf::DW_OP_plus, 6, dwarf::DW_OP_deref);
1521   EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_plus, 6);
1522   EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_bit_piece, 3, 7);
1523   EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_plus, 6, dwarf::DW_OP_bit_piece, 3, 7);
1524
1525   // Invalid constructions.
1526   EXPECT_INVALID(~0u);
1527   EXPECT_INVALID(dwarf::DW_OP_plus);
1528   EXPECT_INVALID(dwarf::DW_OP_bit_piece);
1529   EXPECT_INVALID(dwarf::DW_OP_bit_piece, 3);
1530   EXPECT_INVALID(dwarf::DW_OP_bit_piece, 3, 7, dwarf::DW_OP_plus, 3);
1531   EXPECT_INVALID(dwarf::DW_OP_bit_piece, 3, 7, dwarf::DW_OP_deref);
1532
1533 #undef EXPECT_VALID
1534 #undef EXPECT_INVALID
1535 }
1536
1537 typedef MetadataTest MDObjCPropertyTest;
1538
1539 TEST_F(MDObjCPropertyTest, get) {
1540   StringRef Name = "name";
1541   Metadata *File = MDTuple::getDistinct(Context, None);
1542   unsigned Line = 5;
1543   StringRef GetterName = "getter";
1544   StringRef SetterName = "setter";
1545   unsigned Attributes = 7;
1546   Metadata *Type = MDTuple::getDistinct(Context, None);
1547
1548   auto *N = MDObjCProperty::get(Context, Name, File, Line, GetterName,
1549                                 SetterName, Attributes, Type);
1550
1551   EXPECT_EQ(dwarf::DW_TAG_APPLE_property, N->getTag());
1552   EXPECT_EQ(Name, N->getName());
1553   EXPECT_EQ(File, N->getFile());
1554   EXPECT_EQ(Line, N->getLine());
1555   EXPECT_EQ(GetterName, N->getGetterName());
1556   EXPECT_EQ(SetterName, N->getSetterName());
1557   EXPECT_EQ(Attributes, N->getAttributes());
1558   EXPECT_EQ(Type, N->getType());
1559   EXPECT_EQ(N, MDObjCProperty::get(Context, Name, File, Line, GetterName,
1560                                    SetterName, Attributes, Type));
1561
1562   EXPECT_NE(N, MDObjCProperty::get(Context, "other", File, Line, GetterName,
1563                                    SetterName, Attributes, Type));
1564   EXPECT_NE(N, MDObjCProperty::get(Context, Name, Type, Line, GetterName,
1565                                    SetterName, Attributes, Type));
1566   EXPECT_NE(N, MDObjCProperty::get(Context, Name, File, Line + 1, GetterName,
1567                                    SetterName, Attributes, Type));
1568   EXPECT_NE(N, MDObjCProperty::get(Context, Name, File, Line, "other",
1569                                    SetterName, Attributes, Type));
1570   EXPECT_NE(N, MDObjCProperty::get(Context, Name, File, Line, GetterName,
1571                                    "other", Attributes, Type));
1572   EXPECT_NE(N, MDObjCProperty::get(Context, Name, File, Line, GetterName,
1573                                    SetterName, Attributes + 1, Type));
1574   EXPECT_NE(N, MDObjCProperty::get(Context, Name, File, Line, GetterName,
1575                                    SetterName, Attributes, File));
1576
1577   TempMDObjCProperty Temp = N->clone();
1578   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1579 }
1580
1581 typedef MetadataTest MDImportedEntityTest;
1582
1583 TEST_F(MDImportedEntityTest, get) {
1584   unsigned Tag = dwarf::DW_TAG_imported_module;
1585   Metadata *Scope = MDTuple::getDistinct(Context, None);
1586   Metadata *Entity = MDTuple::getDistinct(Context, None);
1587   unsigned Line = 5;
1588   StringRef Name = "name";
1589
1590   auto *N = MDImportedEntity::get(Context, Tag, Scope, Entity, Line, Name);
1591
1592   EXPECT_EQ(Tag, N->getTag());
1593   EXPECT_EQ(Scope, N->getScope());
1594   EXPECT_EQ(Entity, N->getEntity());
1595   EXPECT_EQ(Line, N->getLine());
1596   EXPECT_EQ(Name, N->getName());
1597   EXPECT_EQ(N, MDImportedEntity::get(Context, Tag, Scope, Entity, Line, Name));
1598
1599   EXPECT_NE(N,
1600             MDImportedEntity::get(Context, dwarf::DW_TAG_imported_declaration,
1601                                   Scope, Entity, Line, Name));
1602   EXPECT_NE(N, MDImportedEntity::get(Context, Tag, Entity, Entity, Line, Name));
1603   EXPECT_NE(N, MDImportedEntity::get(Context, Tag, Scope, Scope, Line, Name));
1604   EXPECT_NE(N,
1605             MDImportedEntity::get(Context, Tag, Scope, Entity, Line + 1, Name));
1606   EXPECT_NE(N,
1607             MDImportedEntity::get(Context, Tag, Scope, Entity, Line, "other"));
1608
1609   TempMDImportedEntity Temp = N->clone();
1610   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1611 }
1612
1613 typedef MetadataTest MetadataAsValueTest;
1614
1615 TEST_F(MetadataAsValueTest, MDNode) {
1616   MDNode *N = MDNode::get(Context, None);
1617   auto *V = MetadataAsValue::get(Context, N);
1618   EXPECT_TRUE(V->getType()->isMetadataTy());
1619   EXPECT_EQ(N, V->getMetadata());
1620
1621   auto *V2 = MetadataAsValue::get(Context, N);
1622   EXPECT_EQ(V, V2);
1623 }
1624
1625 TEST_F(MetadataAsValueTest, MDNodeMDNode) {
1626   MDNode *N = MDNode::get(Context, None);
1627   Metadata *Ops[] = {N};
1628   MDNode *N2 = MDNode::get(Context, Ops);
1629   auto *V = MetadataAsValue::get(Context, N2);
1630   EXPECT_TRUE(V->getType()->isMetadataTy());
1631   EXPECT_EQ(N2, V->getMetadata());
1632
1633   auto *V2 = MetadataAsValue::get(Context, N2);
1634   EXPECT_EQ(V, V2);
1635
1636   auto *V3 = MetadataAsValue::get(Context, N);
1637   EXPECT_TRUE(V3->getType()->isMetadataTy());
1638   EXPECT_NE(V, V3);
1639   EXPECT_EQ(N, V3->getMetadata());
1640 }
1641
1642 TEST_F(MetadataAsValueTest, MDNodeConstant) {
1643   auto *C = ConstantInt::getTrue(Context);
1644   auto *MD = ConstantAsMetadata::get(C);
1645   Metadata *Ops[] = {MD};
1646   auto *N = MDNode::get(Context, Ops);
1647
1648   auto *V = MetadataAsValue::get(Context, MD);
1649   EXPECT_TRUE(V->getType()->isMetadataTy());
1650   EXPECT_EQ(MD, V->getMetadata());
1651
1652   auto *V2 = MetadataAsValue::get(Context, N);
1653   EXPECT_EQ(MD, V2->getMetadata());
1654   EXPECT_EQ(V, V2);
1655 }
1656
1657 typedef MetadataTest ValueAsMetadataTest;
1658
1659 TEST_F(ValueAsMetadataTest, UpdatesOnRAUW) {
1660   Type *Ty = Type::getInt1PtrTy(Context);
1661   std::unique_ptr<GlobalVariable> GV0(
1662       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
1663   auto *MD = ValueAsMetadata::get(GV0.get());
1664   EXPECT_TRUE(MD->getValue() == GV0.get());
1665   ASSERT_TRUE(GV0->use_empty());
1666
1667   std::unique_ptr<GlobalVariable> GV1(
1668       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
1669   GV0->replaceAllUsesWith(GV1.get());
1670   EXPECT_TRUE(MD->getValue() == GV1.get());
1671 }
1672
1673 TEST_F(ValueAsMetadataTest, CollidingDoubleUpdates) {
1674   // Create a constant.
1675   ConstantAsMetadata *CI = ConstantAsMetadata::get(
1676       ConstantInt::get(getGlobalContext(), APInt(8, 0)));
1677
1678   // Create a temporary to prevent nodes from resolving.
1679   auto Temp = MDTuple::getTemporary(Context, None);
1680
1681   // When the first operand of N1 gets reset to nullptr, it'll collide with N2.
1682   Metadata *Ops1[] = {CI, CI, Temp.get()};
1683   Metadata *Ops2[] = {nullptr, CI, Temp.get()};
1684
1685   auto *N1 = MDTuple::get(Context, Ops1);
1686   auto *N2 = MDTuple::get(Context, Ops2);
1687   ASSERT_NE(N1, N2);
1688
1689   // Tell metadata that the constant is getting deleted.
1690   //
1691   // After this, N1 will be invalid, so don't touch it.
1692   ValueAsMetadata::handleDeletion(CI->getValue());
1693   EXPECT_EQ(nullptr, N2->getOperand(0));
1694   EXPECT_EQ(nullptr, N2->getOperand(1));
1695   EXPECT_EQ(Temp.get(), N2->getOperand(2));
1696
1697   // Clean up Temp for teardown.
1698   Temp->replaceAllUsesWith(nullptr);
1699 }
1700
1701 typedef MetadataTest TrackingMDRefTest;
1702
1703 TEST_F(TrackingMDRefTest, UpdatesOnRAUW) {
1704   Type *Ty = Type::getInt1PtrTy(Context);
1705   std::unique_ptr<GlobalVariable> GV0(
1706       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
1707   TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV0.get()));
1708   EXPECT_TRUE(MD->getValue() == GV0.get());
1709   ASSERT_TRUE(GV0->use_empty());
1710
1711   std::unique_ptr<GlobalVariable> GV1(
1712       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
1713   GV0->replaceAllUsesWith(GV1.get());
1714   EXPECT_TRUE(MD->getValue() == GV1.get());
1715
1716   // Reset it, so we don't inadvertently test deletion.
1717   MD.reset();
1718 }
1719
1720 TEST_F(TrackingMDRefTest, UpdatesOnDeletion) {
1721   Type *Ty = Type::getInt1PtrTy(Context);
1722   std::unique_ptr<GlobalVariable> GV(
1723       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
1724   TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV.get()));
1725   EXPECT_TRUE(MD->getValue() == GV.get());
1726   ASSERT_TRUE(GV->use_empty());
1727
1728   GV.reset();
1729   EXPECT_TRUE(!MD);
1730 }
1731
1732 TEST(NamedMDNodeTest, Search) {
1733   LLVMContext Context;
1734   ConstantAsMetadata *C =
1735       ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 1));
1736   ConstantAsMetadata *C2 =
1737       ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 2));
1738
1739   Metadata *const V = C;
1740   Metadata *const V2 = C2;
1741   MDNode *n = MDNode::get(Context, V);
1742   MDNode *n2 = MDNode::get(Context, V2);
1743
1744   Module M("MyModule", Context);
1745   const char *Name = "llvm.NMD1";
1746   NamedMDNode *NMD = M.getOrInsertNamedMetadata(Name);
1747   NMD->addOperand(n);
1748   NMD->addOperand(n2);
1749
1750   std::string Str;
1751   raw_string_ostream oss(Str);
1752   NMD->print(oss);
1753   EXPECT_STREQ("!llvm.NMD1 = !{!0, !1}\n",
1754                oss.str().c_str());
1755 }
1756 }