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 TEST_F(MDSubrangeTest, getEmptyArray) {
 674   auto *N = MDSubrange::get(Context, -1, 0);
 675   EXPECT_EQ(dwarf::DW_TAG_subrange_type, N->getTag());
 676   EXPECT_EQ(-1, N->getCount());
 677   EXPECT_EQ(0, N->getLo());
 678   EXPECT_EQ(N, MDSubrange::get(Context, -1, 0));
 679 }
 680
 681 typedef MetadataTest MDEnumeratorTest;
 682
 683 TEST_F(MDEnumeratorTest, get) {
 684   auto *N = MDEnumerator::get(Context, 7, "name");
 685   EXPECT_EQ(dwarf::DW_TAG_enumerator, N->getTag());
 686   EXPECT_EQ(7, N->getValue());
 687   EXPECT_EQ("name", N->getName());
 688   EXPECT_EQ(N, MDEnumerator::get(Context, 7, "name"));
 689
 690   EXPECT_NE(N, MDEnumerator::get(Context, 8, "name"));
 691   EXPECT_NE(N, MDEnumerator::get(Context, 7, "nam"));
 692
 693   TempMDEnumerator Temp = N->clone();
 694   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 695 }
 696
 697 typedef MetadataTest MDBasicTypeTest;
 698
 699 TEST_F(MDBasicTypeTest, get) {
 700   auto *N =
 701       MDBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33, 26, 7);
 702   EXPECT_EQ(dwarf::DW_TAG_base_type, N->getTag());
 703   EXPECT_EQ("special", N->getName());
 704   EXPECT_EQ(33u, N->getSizeInBits());
 705   EXPECT_EQ(26u, N->getAlignInBits());
 706   EXPECT_EQ(7u, N->getEncoding());
 707   EXPECT_EQ(0u, N->getLine());
 708   EXPECT_EQ(N, MDBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
 709                                 26, 7));
 710
 711   EXPECT_NE(N, MDBasicType::get(Context, dwarf::DW_TAG_unspecified_type,
 712                                 "special", 33, 26, 7));
 713   EXPECT_NE(N,
 714             MDBasicType::get(Context, dwarf::DW_TAG_base_type, "s", 33, 26, 7));
 715   EXPECT_NE(N, MDBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 32,
 716                                 26, 7));
 717   EXPECT_NE(N, MDBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
 718                                 25, 7));
 719   EXPECT_NE(N, MDBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
 720                                 26, 6));
 721
 722   TempMDBasicType Temp = N->clone();
 723   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 724 }
 725
 726 typedef MetadataTest MDDerivedTypeTest;
 727
 728 TEST_F(MDDerivedTypeTest, get) {
 729   Metadata *File = MDTuple::getDistinct(Context, None);
 730   Metadata *Scope = MDTuple::getDistinct(Context, None);
 731   Metadata *BaseType = MDTuple::getDistinct(Context, None);
 732   Metadata *ExtraData = MDTuple::getDistinct(Context, None);
 733
 734   auto *N = MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",
 735                                File, 1, Scope, BaseType, 2, 3, 4, 5, ExtraData);
 736   EXPECT_EQ(dwarf::DW_TAG_pointer_type, N->getTag());
 737   EXPECT_EQ("something", N->getName());
 738   EXPECT_EQ(File, N->getFile());
 739   EXPECT_EQ(1u, N->getLine());
 740   EXPECT_EQ(Scope, N->getScope());
 741   EXPECT_EQ(BaseType, N->getBaseType());
 742   EXPECT_EQ(2u, N->getSizeInBits());
 743   EXPECT_EQ(3u, N->getAlignInBits());
 744   EXPECT_EQ(4u, N->getOffsetInBits());
 745   EXPECT_EQ(5u, N->getFlags());
 746   EXPECT_EQ(ExtraData, N->getExtraData());
 747   EXPECT_EQ(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
 748                                   "something", File, 1, Scope, BaseType, 2, 3,
 749                                   4, 5, ExtraData));
 750
 751   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_reference_type,
 752                                   "something", File, 1, Scope, BaseType, 2, 3,
 753                                   4, 5, ExtraData));
 754   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "else",
 755                                   File, 1, Scope, BaseType, 2, 3, 4, 5,
 756                                   ExtraData));
 757   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
 758                                   "something", Scope, 1, Scope, BaseType, 2, 3,
 759                                   4, 5, ExtraData));
 760   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
 761                                   "something", File, 2, Scope, BaseType, 2, 3,
 762                                   4, 5, ExtraData));
 763   EXPECT_NE(N,
 764             MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",
 765                                File, 1, File, BaseType, 2, 3, 4, 5, ExtraData));
 766   EXPECT_NE(N,
 767             MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",
 768                                File, 1, Scope, File, 2, 3, 4, 5, ExtraData));
 769   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
 770                                   "something", File, 1, Scope, BaseType, 3, 3,
 771                                   4, 5, ExtraData));
 772   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
 773                                   "something", File, 1, Scope, BaseType, 2, 2,
 774                                   4, 5, ExtraData));
 775   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
 776                                   "something", File, 1, Scope, BaseType, 2, 3,
 777                                   5, 5, ExtraData));
 778   EXPECT_NE(N, MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type,
 779                                   "something", File, 1, Scope, BaseType, 2, 3,
 780                                   4, 4, ExtraData));
 781   EXPECT_NE(N,
 782             MDDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",
 783                                File, 1, Scope, BaseType, 2, 3, 4, 5, File));
 784
 785   TempMDDerivedType Temp = N->clone();
 786   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 787 }
 788
 789 typedef MetadataTest MDCompositeTypeTest;
 790
 791 TEST_F(MDCompositeTypeTest, get) {
 792   unsigned Tag = dwarf::DW_TAG_structure_type;
 793   StringRef Name = "some name";
 794   Metadata *File = MDTuple::getDistinct(Context, None);
 795   unsigned Line = 1;
 796   Metadata *Scope = MDTuple::getDistinct(Context, None);
 797   Metadata *BaseType = MDTuple::getDistinct(Context, None);
 798   unsigned SizeInBits = 2;
 799   unsigned AlignInBits = 3;
 800   unsigned OffsetInBits = 4;
 801   unsigned Flags = 5;
 802   Metadata *Elements = MDTuple::getDistinct(Context, None);
 803   unsigned RuntimeLang = 6;
 804   Metadata *VTableHolder = MDTuple::getDistinct(Context, None);
 805   Metadata *TemplateParams = MDTuple::getDistinct(Context, None);
 806   StringRef Identifier = "some id";
 807
 808   auto *N = MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 809                                  BaseType, SizeInBits, AlignInBits,
 810                                  OffsetInBits, Flags, Elements, RuntimeLang,
 811                                  VTableHolder, TemplateParams, Identifier);
 812   EXPECT_EQ(Tag, N->getTag());
 813   EXPECT_EQ(Name, N->getName());
 814   EXPECT_EQ(File, N->getFile());
 815   EXPECT_EQ(Line, N->getLine());
 816   EXPECT_EQ(Scope, N->getScope());
 817   EXPECT_EQ(BaseType, N->getBaseType());
 818   EXPECT_EQ(SizeInBits, N->getSizeInBits());
 819   EXPECT_EQ(AlignInBits, N->getAlignInBits());
 820   EXPECT_EQ(OffsetInBits, N->getOffsetInBits());
 821   EXPECT_EQ(Flags, N->getFlags());
 822   EXPECT_EQ(Elements, N->getElements());
 823   EXPECT_EQ(RuntimeLang, N->getRuntimeLang());
 824   EXPECT_EQ(VTableHolder, N->getVTableHolder());
 825   EXPECT_EQ(TemplateParams, N->getTemplateParams());
 826   EXPECT_EQ(Identifier, N->getIdentifier());
 827
 828   EXPECT_EQ(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 829                                     BaseType, SizeInBits, AlignInBits,
 830                                     OffsetInBits, Flags, Elements, RuntimeLang,
 831                                     VTableHolder, TemplateParams, Identifier));
 832
 833   EXPECT_NE(N, MDCompositeType::get(Context, Tag + 1, Name, File, Line, Scope,
 834                                     BaseType, SizeInBits, AlignInBits,
 835                                     OffsetInBits, Flags, Elements, RuntimeLang,
 836                                     VTableHolder, TemplateParams, Identifier));
 837   EXPECT_NE(N, MDCompositeType::get(Context, Tag, "abc", File, Line, Scope,
 838                                     BaseType, SizeInBits, AlignInBits,
 839                                     OffsetInBits, Flags, Elements, RuntimeLang,
 840                                     VTableHolder, TemplateParams, Identifier));
 841   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, Scope, Line, Scope,
 842                                     BaseType, SizeInBits, AlignInBits,
 843                                     OffsetInBits, Flags, Elements, RuntimeLang,
 844                                     VTableHolder, TemplateParams, Identifier));
 845   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line + 1, Scope,
 846                                     BaseType, SizeInBits, AlignInBits,
 847                                     OffsetInBits, Flags, Elements, RuntimeLang,
 848                                     VTableHolder, TemplateParams, Identifier));
 849   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, File,
 850                                     BaseType, SizeInBits, AlignInBits,
 851                                     OffsetInBits, Flags, Elements, RuntimeLang,
 852                                     VTableHolder, TemplateParams, Identifier));
 853   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope, File,
 854                                     SizeInBits, AlignInBits, OffsetInBits,
 855                                     Flags, Elements, RuntimeLang, VTableHolder,
 856                                     TemplateParams, Identifier));
 857   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 858                                     BaseType, SizeInBits + 1, AlignInBits,
 859                                     OffsetInBits, Flags, Elements, RuntimeLang,
 860                                     VTableHolder, TemplateParams, Identifier));
 861   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 862                                     BaseType, SizeInBits, AlignInBits + 1,
 863                                     OffsetInBits, Flags, Elements, RuntimeLang,
 864                                     VTableHolder, TemplateParams, Identifier));
 865   EXPECT_NE(N, MDCompositeType::get(
 866                    Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
 867                    AlignInBits, OffsetInBits + 1, Flags, Elements, RuntimeLang,
 868                    VTableHolder, TemplateParams, Identifier));
 869   EXPECT_NE(N, MDCompositeType::get(
 870                    Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
 871                    AlignInBits, OffsetInBits, Flags + 1, Elements, RuntimeLang,
 872                    VTableHolder, TemplateParams, Identifier));
 873   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 874                                     BaseType, SizeInBits, AlignInBits,
 875                                     OffsetInBits, Flags, File, RuntimeLang,
 876                                     VTableHolder, TemplateParams, Identifier));
 877   EXPECT_NE(N, MDCompositeType::get(
 878                    Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
 879                    AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang + 1,
 880                    VTableHolder, TemplateParams, Identifier));
 881   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 882                                     BaseType, SizeInBits, AlignInBits,
 883                                     OffsetInBits, Flags, Elements, RuntimeLang,
 884                                     File, TemplateParams, Identifier));
 885   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 886                                     BaseType, SizeInBits, AlignInBits,
 887                                     OffsetInBits, Flags, Elements, RuntimeLang,
 888                                     VTableHolder, File, Identifier));
 889   EXPECT_NE(N, MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 890                                     BaseType, SizeInBits, AlignInBits,
 891                                     OffsetInBits, Flags, Elements, RuntimeLang,
 892                                     VTableHolder, TemplateParams, "other"));
 893
 894   // Be sure that missing identifiers get null pointers.
 895   EXPECT_FALSE(MDCompositeType::get(
 896                    Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
 897                    AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
 898                    VTableHolder, TemplateParams, "")->getRawIdentifier());
 899   EXPECT_FALSE(MDCompositeType::get(
 900                    Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
 901                    AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
 902                    VTableHolder, TemplateParams)->getRawIdentifier());
 903
 904   TempMDCompositeType Temp = N->clone();
 905   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 906 }
 907
 908 TEST_F(MDCompositeTypeTest, replaceOperands) {
 909   unsigned Tag = dwarf::DW_TAG_structure_type;
 910   StringRef Name = "some name";
 911   Metadata *File = MDTuple::getDistinct(Context, None);
 912   unsigned Line = 1;
 913   Metadata *Scope = MDTuple::getDistinct(Context, None);
 914   Metadata *BaseType = MDTuple::getDistinct(Context, None);
 915   unsigned SizeInBits = 2;
 916   unsigned AlignInBits = 3;
 917   unsigned OffsetInBits = 4;
 918   unsigned Flags = 5;
 919   unsigned RuntimeLang = 6;
 920   StringRef Identifier = "some id";
 921
 922   auto *N = MDCompositeType::get(Context, Tag, Name, File, Line, Scope,
 923                                  BaseType, SizeInBits, AlignInBits,
 924                                  OffsetInBits, Flags, nullptr, RuntimeLang,
 925                                  nullptr, nullptr, Identifier);
 926
 927   auto *Elements = MDTuple::getDistinct(Context, None);
 928   EXPECT_EQ(nullptr, N->getElements());
 929   N->replaceElements(Elements);
 930   EXPECT_EQ(Elements, N->getElements());
 931   N->replaceElements(nullptr);
 932   EXPECT_EQ(nullptr, N->getElements());
 933
 934   auto *VTableHolder = MDTuple::getDistinct(Context, None);
 935   EXPECT_EQ(nullptr, N->getVTableHolder());
 936   N->replaceVTableHolder(VTableHolder);
 937   EXPECT_EQ(VTableHolder, N->getVTableHolder());
 938   N->replaceVTableHolder(nullptr);
 939   EXPECT_EQ(nullptr, N->getVTableHolder());
 940
 941   auto *TemplateParams = MDTuple::getDistinct(Context, None);
 942   EXPECT_EQ(nullptr, N->getTemplateParams());
 943   N->replaceTemplateParams(TemplateParams);
 944   EXPECT_EQ(TemplateParams, N->getTemplateParams());
 945   N->replaceTemplateParams(nullptr);
 946   EXPECT_EQ(nullptr, N->getTemplateParams());
 947 }
 948
 949 typedef MetadataTest MDSubroutineTypeTest;
 950
 951 TEST_F(MDSubroutineTypeTest, get) {
 952   unsigned Flags = 1;
 953   Metadata *TypeArray = MDTuple::getDistinct(Context, None);
 954
 955   auto *N = MDSubroutineType::get(Context, Flags, TypeArray);
 956   EXPECT_EQ(dwarf::DW_TAG_subroutine_type, N->getTag());
 957   EXPECT_EQ(Flags, N->getFlags());
 958   EXPECT_EQ(TypeArray, N->getTypeArray());
 959   EXPECT_EQ(N, MDSubroutineType::get(Context, Flags, TypeArray));
 960
 961   EXPECT_NE(N, MDSubroutineType::get(Context, Flags + 1, TypeArray));
 962   EXPECT_NE(N, MDSubroutineType::get(Context, Flags,
 963                                      MDTuple::getDistinct(Context, None)));
 964
 965   TempMDSubroutineType Temp = N->clone();
 966   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 967 }
 968
 969 typedef MetadataTest MDFileTest;
 970
 971 TEST_F(MDFileTest, get) {
 972   StringRef Filename = "file";
 973   StringRef Directory = "dir";
 974   auto *N = MDFile::get(Context, Filename, Directory);
 975
 976   EXPECT_EQ(dwarf::DW_TAG_file_type, N->getTag());
 977   EXPECT_EQ(Filename, N->getFilename());
 978   EXPECT_EQ(Directory, N->getDirectory());
 979   EXPECT_EQ(N, MDFile::get(Context, Filename, Directory));
 980
 981   EXPECT_NE(N, MDFile::get(Context, "other", Directory));
 982   EXPECT_NE(N, MDFile::get(Context, Filename, "other"));
 983
 984   TempMDFile Temp = N->clone();
 985   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 986 }
 987
 988 typedef MetadataTest MDCompileUnitTest;
 989
 990 TEST_F(MDCompileUnitTest, get) {
 991   unsigned SourceLanguage = 1;
 992   Metadata *File = MDTuple::getDistinct(Context, None);
 993   StringRef Producer = "some producer";
 994   bool IsOptimized = false;
 995   StringRef Flags = "flag after flag";
 996   unsigned RuntimeVersion = 2;
 997   StringRef SplitDebugFilename = "another/file";
 998   unsigned EmissionKind = 3;
 999   Metadata *EnumTypes = MDTuple::getDistinct(Context, None);
1000   Metadata *RetainedTypes = MDTuple::getDistinct(Context, None);
1001   Metadata *Subprograms = MDTuple::getDistinct(Context, None);
1002   Metadata *GlobalVariables = MDTuple::getDistinct(Context, None);
1003   Metadata *ImportedEntities = MDTuple::getDistinct(Context, None);
1004   auto *N = MDCompileUnit::get(
1005       Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1006       RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1007       RetainedTypes, Subprograms, GlobalVariables, ImportedEntities);
1008
1009   EXPECT_EQ(dwarf::DW_TAG_compile_unit, N->getTag());
1010   EXPECT_EQ(SourceLanguage, N->getSourceLanguage());
1011   EXPECT_EQ(File, N->getFile());
1012   EXPECT_EQ(Producer, N->getProducer());
1013   EXPECT_EQ(IsOptimized, N->isOptimized());
1014   EXPECT_EQ(Flags, N->getFlags());
1015   EXPECT_EQ(RuntimeVersion, N->getRuntimeVersion());
1016   EXPECT_EQ(SplitDebugFilename, N->getSplitDebugFilename());
1017   EXPECT_EQ(EmissionKind, N->getEmissionKind());
1018   EXPECT_EQ(EnumTypes, N->getEnumTypes());
1019   EXPECT_EQ(RetainedTypes, N->getRetainedTypes());
1020   EXPECT_EQ(Subprograms, N->getSubprograms());
1021   EXPECT_EQ(GlobalVariables, N->getGlobalVariables());
1022   EXPECT_EQ(ImportedEntities, N->getImportedEntities());
1023   EXPECT_EQ(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
1024                                   IsOptimized, Flags, RuntimeVersion,
1025                                   SplitDebugFilename, EmissionKind, EnumTypes,
1026                                   RetainedTypes, Subprograms, GlobalVariables,
1027                                   ImportedEntities));
1028
1029   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage + 1, File, Producer,
1030                                   IsOptimized, Flags, RuntimeVersion,
1031                                   SplitDebugFilename, EmissionKind, EnumTypes,
1032                                   RetainedTypes, Subprograms, GlobalVariables,
1033                                   ImportedEntities));
1034   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, EnumTypes, Producer,
1035                                   IsOptimized, Flags, RuntimeVersion,
1036                                   SplitDebugFilename, EmissionKind, EnumTypes,
1037                                   RetainedTypes, Subprograms, GlobalVariables,
1038                                   ImportedEntities));
1039   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, "other",
1040                                   IsOptimized, Flags, RuntimeVersion,
1041                                   SplitDebugFilename, EmissionKind, EnumTypes,
1042                                   RetainedTypes, Subprograms, GlobalVariables,
1043                                   ImportedEntities));
1044   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
1045                                   !IsOptimized, Flags, RuntimeVersion,
1046                                   SplitDebugFilename, EmissionKind, EnumTypes,
1047                                   RetainedTypes, Subprograms, GlobalVariables,
1048                                   ImportedEntities));
1049   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
1050                                   IsOptimized, "other", RuntimeVersion,
1051                                   SplitDebugFilename, EmissionKind, EnumTypes,
1052                                   RetainedTypes, Subprograms, GlobalVariables,
1053                                   ImportedEntities));
1054   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
1055                                   IsOptimized, Flags, RuntimeVersion + 1,
1056                                   SplitDebugFilename, EmissionKind, EnumTypes,
1057                                   RetainedTypes, Subprograms, GlobalVariables,
1058                                   ImportedEntities));
1059   EXPECT_NE(N,
1060             MDCompileUnit::get(Context, SourceLanguage, File, Producer,
1061                                IsOptimized, Flags, RuntimeVersion, "other",
1062                                EmissionKind, EnumTypes, RetainedTypes,
1063                                Subprograms, GlobalVariables, ImportedEntities));
1064   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
1065                                   IsOptimized, Flags, RuntimeVersion,
1066                                   SplitDebugFilename, EmissionKind + 1,
1067                                   EnumTypes, RetainedTypes, Subprograms,
1068                                   GlobalVariables, ImportedEntities));
1069   EXPECT_NE(N, MDCompileUnit::get(Context, SourceLanguage, File, Producer,
1070                                   IsOptimized, Flags, RuntimeVersion,
1071                                   SplitDebugFilename, EmissionKind, File,
1072                                   RetainedTypes, Subprograms, GlobalVariables,
1073                                   ImportedEntities));
1074   EXPECT_NE(N, MDCompileUnit::get(
1075                    Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1076                    RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1077                    File, Subprograms, GlobalVariables, ImportedEntities));
1078   EXPECT_NE(N, MDCompileUnit::get(
1079                    Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1080                    RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1081                    RetainedTypes, File, GlobalVariables, ImportedEntities));
1082   EXPECT_NE(N, MDCompileUnit::get(
1083                    Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1084                    RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1085                    RetainedTypes, Subprograms, File, ImportedEntities));
1086   EXPECT_NE(N, MDCompileUnit::get(
1087                    Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1088                    RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1089                    RetainedTypes, Subprograms, GlobalVariables, File));
1090
1091   TempMDCompileUnit Temp = N->clone();
1092   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1093 }
1094
1095 TEST_F(MDCompileUnitTest, replaceArrays) {
1096   unsigned SourceLanguage = 1;
1097   Metadata *File = MDTuple::getDistinct(Context, None);
1098   StringRef Producer = "some producer";
1099   bool IsOptimized = false;
1100   StringRef Flags = "flag after flag";
1101   unsigned RuntimeVersion = 2;
1102   StringRef SplitDebugFilename = "another/file";
1103   unsigned EmissionKind = 3;
1104   Metadata *EnumTypes = MDTuple::getDistinct(Context, None);
1105   Metadata *RetainedTypes = MDTuple::getDistinct(Context, None);
1106   Metadata *ImportedEntities = MDTuple::getDistinct(Context, None);
1107   auto *N = MDCompileUnit::get(
1108       Context, SourceLanguage, File, Producer, IsOptimized, Flags,
1109       RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
1110       RetainedTypes, nullptr, nullptr, ImportedEntities);
1111
1112   auto *Subprograms = MDTuple::getDistinct(Context, None);
1113   EXPECT_EQ(nullptr, N->getSubprograms());
1114   N->replaceSubprograms(Subprograms);
1115   EXPECT_EQ(Subprograms, N->getSubprograms());
1116   N->replaceSubprograms(nullptr);
1117   EXPECT_EQ(nullptr, N->getSubprograms());
1118
1119   auto *GlobalVariables = MDTuple::getDistinct(Context, None);
1120   EXPECT_EQ(nullptr, N->getGlobalVariables());
1121   N->replaceGlobalVariables(GlobalVariables);
1122   EXPECT_EQ(GlobalVariables, N->getGlobalVariables());
1123   N->replaceGlobalVariables(nullptr);
1124   EXPECT_EQ(nullptr, N->getGlobalVariables());
1125 }
1126
1127 typedef MetadataTest MDSubprogramTest;
1128
1129 TEST_F(MDSubprogramTest, get) {
1130   Metadata *Scope = MDTuple::getDistinct(Context, None);
1131   StringRef Name = "name";
1132   StringRef LinkageName = "linkage";
1133   Metadata *File = MDTuple::getDistinct(Context, None);
1134   unsigned Line = 2;
1135   Metadata *Type = MDTuple::getDistinct(Context, None);
1136   bool IsLocalToUnit = false;
1137   bool IsDefinition = true;
1138   unsigned ScopeLine = 3;
1139   Metadata *ContainingType = MDTuple::getDistinct(Context, None);
1140   unsigned Virtuality = 4;
1141   unsigned VirtualIndex = 5;
1142   unsigned Flags = 6;
1143   bool IsOptimized = false;
1144   Metadata *Function = MDTuple::getDistinct(Context, None);
1145   Metadata *TemplateParams = MDTuple::getDistinct(Context, None);
1146   Metadata *Declaration = MDTuple::getDistinct(Context, None);
1147   Metadata *Variables = MDTuple::getDistinct(Context, None);
1148
1149   auto *N = MDSubprogram::get(
1150       Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1151       IsDefinition, ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags,
1152       IsOptimized, Function, TemplateParams, Declaration, Variables);
1153
1154   EXPECT_EQ(dwarf::DW_TAG_subprogram, N->getTag());
1155   EXPECT_EQ(Scope, N->getScope());
1156   EXPECT_EQ(Name, N->getName());
1157   EXPECT_EQ(LinkageName, N->getLinkageName());
1158   EXPECT_EQ(File, N->getFile());
1159   EXPECT_EQ(Line, N->getLine());
1160   EXPECT_EQ(Type, N->getType());
1161   EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());
1162   EXPECT_EQ(IsDefinition, N->isDefinition());
1163   EXPECT_EQ(ScopeLine, N->getScopeLine());
1164   EXPECT_EQ(ContainingType, N->getContainingType());
1165   EXPECT_EQ(Virtuality, N->getVirtuality());
1166   EXPECT_EQ(VirtualIndex, N->getVirtualIndex());
1167   EXPECT_EQ(Flags, N->getFlags());
1168   EXPECT_EQ(IsOptimized, N->isOptimized());
1169   EXPECT_EQ(Function, N->getFunction());
1170   EXPECT_EQ(TemplateParams, N->getTemplateParams());
1171   EXPECT_EQ(Declaration, N->getDeclaration());
1172   EXPECT_EQ(Variables, N->getVariables());
1173   EXPECT_EQ(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1174                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1175                                  ContainingType, Virtuality, VirtualIndex,
1176                                  Flags, IsOptimized, Function, TemplateParams,
1177                                  Declaration, Variables));
1178
1179   EXPECT_NE(N, MDSubprogram::get(Context, File, Name, LinkageName, File, Line,
1180                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1181                                  ContainingType, Virtuality, VirtualIndex,
1182                                  Flags, IsOptimized, Function, TemplateParams,
1183                                  Declaration, Variables));
1184   EXPECT_NE(N, MDSubprogram::get(Context, Scope, "other", LinkageName, File,
1185                                  Line, Type, IsLocalToUnit, IsDefinition,
1186                                  ScopeLine, ContainingType, Virtuality,
1187                                  VirtualIndex, Flags, IsOptimized, Function,
1188                                  TemplateParams, Declaration, Variables));
1189   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, "other", File, Line,
1190                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1191                                  ContainingType, Virtuality, VirtualIndex,
1192                                  Flags, IsOptimized, Function, TemplateParams,
1193                                  Declaration, Variables));
1194   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, Scope, Line,
1195                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1196                                  ContainingType, Virtuality, VirtualIndex,
1197                                  Flags, IsOptimized, Function, TemplateParams,
1198                                  Declaration, Variables));
1199   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File,
1200                                  Line + 1, Type, IsLocalToUnit, IsDefinition,
1201                                  ScopeLine, ContainingType, Virtuality,
1202                                  VirtualIndex, Flags, IsOptimized, Function,
1203                                  TemplateParams, Declaration, Variables));
1204   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1205                                  Scope, IsLocalToUnit, IsDefinition, ScopeLine,
1206                                  ContainingType, Virtuality, VirtualIndex,
1207                                  Flags, IsOptimized, Function, TemplateParams,
1208                                  Declaration, Variables));
1209   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1210                                  Type, !IsLocalToUnit, IsDefinition, ScopeLine,
1211                                  ContainingType, Virtuality, VirtualIndex,
1212                                  Flags, IsOptimized, Function, TemplateParams,
1213                                  Declaration, Variables));
1214   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1215                                  Type, IsLocalToUnit, !IsDefinition, ScopeLine,
1216                                  ContainingType, Virtuality, VirtualIndex,
1217                                  Flags, IsOptimized, Function, TemplateParams,
1218                                  Declaration, Variables));
1219   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1220                                  Type, IsLocalToUnit, IsDefinition,
1221                                  ScopeLine + 1, ContainingType, Virtuality,
1222                                  VirtualIndex, Flags, IsOptimized, Function,
1223                                  TemplateParams, Declaration, Variables));
1224   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1225                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1226                                  Type, Virtuality, VirtualIndex, Flags,
1227                                  IsOptimized, Function, TemplateParams,
1228                                  Declaration, Variables));
1229   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1230                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1231                                  ContainingType, Virtuality + 1, VirtualIndex,
1232                                  Flags, IsOptimized, Function, TemplateParams,
1233                                  Declaration, Variables));
1234   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1235                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1236                                  ContainingType, Virtuality, VirtualIndex + 1,
1237                                  Flags, IsOptimized, Function, TemplateParams,
1238                                  Declaration, Variables));
1239   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1240                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1241                                  ContainingType, Virtuality, VirtualIndex,
1242                                  ~Flags, IsOptimized, Function, TemplateParams,
1243                                  Declaration, Variables));
1244   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1245                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1246                                  ContainingType, Virtuality, VirtualIndex,
1247                                  Flags, !IsOptimized, Function, TemplateParams,
1248                                  Declaration, Variables));
1249   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1250                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1251                                  ContainingType, Virtuality, VirtualIndex,
1252                                  Flags, IsOptimized, Type, TemplateParams,
1253                                  Declaration, Variables));
1254   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1255                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1256                                  ContainingType, Virtuality, VirtualIndex,
1257                                  Flags, IsOptimized, Function, Type,
1258                                  Declaration, Variables));
1259   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1260                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1261                                  ContainingType, Virtuality, VirtualIndex,
1262                                  Flags, IsOptimized, Function, TemplateParams,
1263                                  Type, Variables));
1264   EXPECT_NE(N, MDSubprogram::get(Context, Scope, Name, LinkageName, File, Line,
1265                                  Type, IsLocalToUnit, IsDefinition, ScopeLine,
1266                                  ContainingType, Virtuality, VirtualIndex,
1267                                  Flags, IsOptimized, Function, TemplateParams,
1268                                  Declaration, Type));
1269
1270   TempMDSubprogram Temp = N->clone();
1271   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1272 }
1273
1274 TEST_F(MDSubprogramTest, replaceFunction) {
1275   Metadata *Scope = MDTuple::getDistinct(Context, None);
1276   StringRef Name = "name";
1277   StringRef LinkageName = "linkage";
1278   Metadata *File = MDTuple::getDistinct(Context, None);
1279   unsigned Line = 2;
1280   Metadata *Type = MDTuple::getDistinct(Context, None);
1281   bool IsLocalToUnit = false;
1282   bool IsDefinition = true;
1283   unsigned ScopeLine = 3;
1284   Metadata *ContainingType = MDTuple::getDistinct(Context, None);
1285   unsigned Virtuality = 4;
1286   unsigned VirtualIndex = 5;
1287   unsigned Flags = 6;
1288   bool IsOptimized = false;
1289   Metadata *TemplateParams = MDTuple::getDistinct(Context, None);
1290   Metadata *Declaration = MDTuple::getDistinct(Context, None);
1291   Metadata *Variables = MDTuple::getDistinct(Context, None);
1292
1293   auto *N = MDSubprogram::get(
1294       Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
1295       IsDefinition, ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags,
1296       IsOptimized, nullptr, TemplateParams, Declaration, Variables);
1297
1298   EXPECT_EQ(nullptr, N->getFunction());
1299
1300   std::unique_ptr<Function> F(
1301       Function::Create(FunctionType::get(Type::getVoidTy(Context), false),
1302                        GlobalValue::ExternalLinkage));
1303   N->replaceFunction(F.get());
1304   EXPECT_EQ(ConstantAsMetadata::get(F.get()), N->getFunction());
1305
1306   N->replaceFunction(nullptr);
1307   EXPECT_EQ(nullptr, N->getFunction());
1308 }
1309
1310 typedef MetadataTest MDLexicalBlockTest;
1311
1312 TEST_F(MDLexicalBlockTest, get) {
1313   Metadata *Scope = MDTuple::getDistinct(Context, None);
1314   Metadata *File = MDTuple::getDistinct(Context, None);
1315   unsigned Line = 5;
1316   unsigned Column = 8;
1317
1318   auto *N = MDLexicalBlock::get(Context, Scope, File, Line, Column);
1319
1320   EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());
1321   EXPECT_EQ(Scope, N->getScope());
1322   EXPECT_EQ(File, N->getFile());
1323   EXPECT_EQ(Line, N->getLine());
1324   EXPECT_EQ(Column, N->getColumn());
1325   EXPECT_EQ(N, MDLexicalBlock::get(Context, Scope, File, Line, Column));
1326
1327   EXPECT_NE(N, MDLexicalBlock::get(Context, File, File, Line, Column));
1328   EXPECT_NE(N, MDLexicalBlock::get(Context, Scope, Scope, Line, Column));
1329   EXPECT_NE(N, MDLexicalBlock::get(Context, Scope, File, Line + 1, Column));
1330   EXPECT_NE(N, MDLexicalBlock::get(Context, Scope, File, Line, Column + 1));
1331
1332   TempMDLexicalBlock Temp = N->clone();
1333   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1334 }
1335
1336 typedef MetadataTest MDLexicalBlockFileTest;
1337
1338 TEST_F(MDLexicalBlockFileTest, get) {
1339   Metadata *Scope = MDTuple::getDistinct(Context, None);
1340   Metadata *File = MDTuple::getDistinct(Context, None);
1341   unsigned Discriminator = 5;
1342
1343   auto *N = MDLexicalBlockFile::get(Context, Scope, File, Discriminator);
1344
1345   EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());
1346   EXPECT_EQ(Scope, N->getScope());
1347   EXPECT_EQ(File, N->getFile());
1348   EXPECT_EQ(Discriminator, N->getDiscriminator());
1349   EXPECT_EQ(N, MDLexicalBlockFile::get(Context, Scope, File, Discriminator));
1350
1351   EXPECT_NE(N, MDLexicalBlockFile::get(Context, File, File, Discriminator));
1352   EXPECT_NE(N, MDLexicalBlockFile::get(Context, Scope, Scope, Discriminator));
1353   EXPECT_NE(N,
1354             MDLexicalBlockFile::get(Context, Scope, File, Discriminator + 1));
1355
1356   TempMDLexicalBlockFile Temp = N->clone();
1357   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1358 }
1359
1360 typedef MetadataTest MDNamespaceTest;
1361
1362 TEST_F(MDNamespaceTest, get) {
1363   Metadata *Scope = MDTuple::getDistinct(Context, None);
1364   Metadata *File = MDTuple::getDistinct(Context, None);
1365   StringRef Name = "namespace";
1366   unsigned Line = 5;
1367
1368   auto *N = MDNamespace::get(Context, Scope, File, Name, Line);
1369
1370   EXPECT_EQ(dwarf::DW_TAG_namespace, N->getTag());
1371   EXPECT_EQ(Scope, N->getScope());
1372   EXPECT_EQ(File, N->getFile());
1373   EXPECT_EQ(Name, N->getName());
1374   EXPECT_EQ(Line, N->getLine());
1375   EXPECT_EQ(N, MDNamespace::get(Context, Scope, File, Name, Line));
1376
1377   EXPECT_NE(N, MDNamespace::get(Context, File, File, Name, Line));
1378   EXPECT_NE(N, MDNamespace::get(Context, Scope, Scope, Name, Line));
1379   EXPECT_NE(N, MDNamespace::get(Context, Scope, File, "other", Line));
1380   EXPECT_NE(N, MDNamespace::get(Context, Scope, File, Name, Line + 1));
1381
1382   TempMDNamespace Temp = N->clone();
1383   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1384 }
1385
1386 typedef MetadataTest MDTemplateTypeParameterTest;
1387
1388 TEST_F(MDTemplateTypeParameterTest, get) {
1389   Metadata *Scope = MDTuple::getDistinct(Context, None);
1390   StringRef Name = "template";
1391   Metadata *Type = MDTuple::getDistinct(Context, None);
1392
1393   auto *N = MDTemplateTypeParameter::get(Context, Scope, Name, Type);
1394
1395   EXPECT_EQ(dwarf::DW_TAG_template_type_parameter, N->getTag());
1396   EXPECT_EQ(Scope, N->getScope());
1397   EXPECT_EQ(Name, N->getName());
1398   EXPECT_EQ(Type, N->getType());
1399   EXPECT_EQ(N, MDTemplateTypeParameter::get(Context, Scope, Name, Type));
1400
1401   EXPECT_NE(N, MDTemplateTypeParameter::get(Context, Type, Name, Type));
1402   EXPECT_NE(N, MDTemplateTypeParameter::get(Context, Scope, "other", Type));
1403   EXPECT_NE(N, MDTemplateTypeParameter::get(Context, Scope, Name, Scope));
1404
1405   TempMDTemplateTypeParameter Temp = N->clone();
1406   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1407 }
1408
1409 typedef MetadataTest MDTemplateValueParameterTest;
1410
1411 TEST_F(MDTemplateValueParameterTest, get) {
1412   unsigned Tag = dwarf::DW_TAG_template_value_parameter;
1413   Metadata *Scope = MDTuple::getDistinct(Context, None);
1414   StringRef Name = "template";
1415   Metadata *Type = MDTuple::getDistinct(Context, None);
1416   Metadata *Value = MDTuple::getDistinct(Context, None);
1417
1418   auto *N =
1419       MDTemplateValueParameter::get(Context, Tag, Scope, Name, Type, Value);
1420   EXPECT_EQ(Tag, N->getTag());
1421   EXPECT_EQ(Scope, N->getScope());
1422   EXPECT_EQ(Name, N->getName());
1423   EXPECT_EQ(Type, N->getType());
1424   EXPECT_EQ(Value, N->getValue());
1425   EXPECT_EQ(
1426       N, MDTemplateValueParameter::get(Context, Tag, Scope, Name, Type, Value));
1427
1428   EXPECT_NE(N, MDTemplateValueParameter::get(
1429                    Context, dwarf::DW_TAG_GNU_template_template_param, Scope,
1430                    Name, Type, Value));
1431   EXPECT_NE(
1432       N, MDTemplateValueParameter::get(Context, Tag, Type, Name, Type, Value));
1433   EXPECT_NE(N, MDTemplateValueParameter::get(Context, Tag, Scope, "other", Type,
1434                                              Value));
1435   EXPECT_NE(N, MDTemplateValueParameter::get(Context, Tag, Scope, Name, Scope,
1436                                              Value));
1437   EXPECT_NE(
1438       N, MDTemplateValueParameter::get(Context, Tag, Scope, Name, Type, Scope));
1439
1440   TempMDTemplateValueParameter Temp = N->clone();
1441   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1442 }
1443
1444 typedef MetadataTest MDGlobalVariableTest;
1445
1446 TEST_F(MDGlobalVariableTest, get) {
1447   Metadata *Scope = MDTuple::getDistinct(Context, None);
1448   StringRef Name = "name";
1449   StringRef LinkageName = "linkage";
1450   Metadata *File = MDTuple::getDistinct(Context, None);
1451   unsigned Line = 5;
1452   Metadata *Type = MDTuple::getDistinct(Context, None);
1453   bool IsLocalToUnit = false;
1454   bool IsDefinition = true;
1455   Metadata *Variable = MDTuple::getDistinct(Context, None);
1456   Metadata *StaticDataMemberDeclaration = MDTuple::getDistinct(Context, None);
1457
1458   auto *N = MDGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,
1459                                   Type, IsLocalToUnit, IsDefinition, Variable,
1460                                   StaticDataMemberDeclaration);
1461   EXPECT_EQ(dwarf::DW_TAG_variable, N->getTag());
1462   EXPECT_EQ(Scope, N->getScope());
1463   EXPECT_EQ(Name, N->getName());
1464   EXPECT_EQ(LinkageName, N->getLinkageName());
1465   EXPECT_EQ(File, N->getFile());
1466   EXPECT_EQ(Line, N->getLine());
1467   EXPECT_EQ(Type, N->getType());
1468   EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());
1469   EXPECT_EQ(IsDefinition, N->isDefinition());
1470   EXPECT_EQ(Variable, N->getVariable());
1471   EXPECT_EQ(StaticDataMemberDeclaration, N->getStaticDataMemberDeclaration());
1472   EXPECT_EQ(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1473                                      Line, Type, IsLocalToUnit, IsDefinition,
1474                                      Variable, StaticDataMemberDeclaration));
1475
1476   EXPECT_NE(N, MDGlobalVariable::get(Context, File, Name, LinkageName, File,
1477                                      Line, Type, IsLocalToUnit, IsDefinition,
1478                                      Variable, StaticDataMemberDeclaration));
1479   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, "other", LinkageName, File,
1480                                      Line, Type, IsLocalToUnit, IsDefinition,
1481                                      Variable, StaticDataMemberDeclaration));
1482   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, "other", File, Line,
1483                                      Type, IsLocalToUnit, IsDefinition,
1484                                      Variable, StaticDataMemberDeclaration));
1485   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, Scope,
1486                                      Line, Type, IsLocalToUnit, IsDefinition,
1487                                      Variable, StaticDataMemberDeclaration));
1488   EXPECT_NE(N,
1489             MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1490                                   Line + 1, Type, IsLocalToUnit, IsDefinition,
1491                                   Variable, StaticDataMemberDeclaration));
1492   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1493                                      Line, Scope, IsLocalToUnit, IsDefinition,
1494                                      Variable, StaticDataMemberDeclaration));
1495   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1496                                      Line, Type, !IsLocalToUnit, IsDefinition,
1497                                      Variable, StaticDataMemberDeclaration));
1498   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1499                                      Line, Type, IsLocalToUnit, !IsDefinition,
1500                                      Variable, StaticDataMemberDeclaration));
1501   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1502                                      Line, Type, IsLocalToUnit, IsDefinition,
1503                                      Type, StaticDataMemberDeclaration));
1504   EXPECT_NE(N, MDGlobalVariable::get(Context, Scope, Name, LinkageName, File,
1505                                      Line, Type, IsLocalToUnit, IsDefinition,
1506                                      Variable, Type));
1507
1508   TempMDGlobalVariable Temp = N->clone();
1509   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1510 }
1511
1512 typedef MetadataTest MDLocalVariableTest;
1513
1514 TEST_F(MDLocalVariableTest, get) {
1515   unsigned Tag = dwarf::DW_TAG_arg_variable;
1516   Metadata *Scope = MDTuple::getDistinct(Context, None);
1517   StringRef Name = "name";
1518   Metadata *File = MDTuple::getDistinct(Context, None);
1519   unsigned Line = 5;
1520   Metadata *Type = MDTuple::getDistinct(Context, None);
1521   unsigned Arg = 6;
1522   unsigned Flags = 7;
1523   Metadata *InlinedAt = MDTuple::getDistinct(Context, None);
1524
1525   auto *N = MDLocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
1526                                  Arg, Flags, InlinedAt);
1527   EXPECT_EQ(Tag, N->getTag());
1528   EXPECT_EQ(Scope, N->getScope());
1529   EXPECT_EQ(Name, N->getName());
1530   EXPECT_EQ(File, N->getFile());
1531   EXPECT_EQ(Line, N->getLine());
1532   EXPECT_EQ(Type, N->getType());
1533   EXPECT_EQ(Arg, N->getArg());
1534   EXPECT_EQ(Flags, N->getFlags());
1535   EXPECT_EQ(InlinedAt, N->getInlinedAt());
1536   EXPECT_EQ(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
1537                                     Arg, Flags, InlinedAt));
1538
1539   EXPECT_NE(N, MDLocalVariable::get(Context, dwarf::DW_TAG_auto_variable, Scope,
1540                                     Name, File, Line, Type, Arg, Flags,
1541                                     InlinedAt));
1542   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, File, Name, File, Line,
1543                                     Type, Arg, Flags, InlinedAt));
1544   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, "other", File, Line,
1545                                     Type, Arg, Flags, InlinedAt));
1546   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, Scope, Line,
1547                                     Type, Arg, Flags, InlinedAt));
1548   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line + 1,
1549                                     Type, Arg, Flags, InlinedAt));
1550   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line,
1551                                     Scope, Arg, Flags, InlinedAt));
1552   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
1553                                     Arg + 1, Flags, InlinedAt));
1554   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
1555                                     Arg, ~Flags, InlinedAt));
1556   EXPECT_NE(N, MDLocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,
1557                                     Arg, Flags, Scope));
1558
1559   TempMDLocalVariable Temp = N->clone();
1560   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1561 }
1562
1563 typedef MetadataTest MDExpressionTest;
1564
1565 TEST_F(MDExpressionTest, get) {
1566   uint64_t Elements[] = {2, 6, 9, 78, 0};
1567   auto *N = MDExpression::get(Context, Elements);
1568   EXPECT_EQ(makeArrayRef(Elements), N->getElements());
1569   EXPECT_EQ(N, MDExpression::get(Context, Elements));
1570
1571   EXPECT_EQ(5u, N->getNumElements());
1572   EXPECT_EQ(2u, N->getElement(0));
1573   EXPECT_EQ(6u, N->getElement(1));
1574   EXPECT_EQ(9u, N->getElement(2));
1575   EXPECT_EQ(78u, N->getElement(3));
1576   EXPECT_EQ(0u, N->getElement(4));
1577
1578   TempMDExpression Temp = N->clone();
1579   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1580 }
1581
1582 TEST_F(MDExpressionTest, isValid) {
1583 #define EXPECT_VALID(...)                                                      \
1584   do {                                                                         \
1585     uint64_t Elements[] = {__VA_ARGS__};                                       \
1586     EXPECT_TRUE(MDExpression::get(Context, Elements)->isValid());              \
1587   } while (false)
1588 #define EXPECT_INVALID(...)                                                    \
1589   do {                                                                         \
1590     uint64_t Elements[] = {__VA_ARGS__};                                       \
1591     EXPECT_FALSE(MDExpression::get(Context, Elements)->isValid());             \
1592   } while (false)
1593
1594   // Empty expression should be valid.
1595   EXPECT_TRUE(MDExpression::get(Context, None));
1596
1597   // Valid constructions.
1598   EXPECT_VALID(dwarf::DW_OP_plus, 6);
1599   EXPECT_VALID(dwarf::DW_OP_deref);
1600   EXPECT_VALID(dwarf::DW_OP_bit_piece, 3, 7);
1601   EXPECT_VALID(dwarf::DW_OP_plus, 6, dwarf::DW_OP_deref);
1602   EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_plus, 6);
1603   EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_bit_piece, 3, 7);
1604   EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_plus, 6, dwarf::DW_OP_bit_piece, 3, 7);
1605
1606   // Invalid constructions.
1607   EXPECT_INVALID(~0u);
1608   EXPECT_INVALID(dwarf::DW_OP_plus);
1609   EXPECT_INVALID(dwarf::DW_OP_bit_piece);
1610   EXPECT_INVALID(dwarf::DW_OP_bit_piece, 3);
1611   EXPECT_INVALID(dwarf::DW_OP_bit_piece, 3, 7, dwarf::DW_OP_plus, 3);
1612   EXPECT_INVALID(dwarf::DW_OP_bit_piece, 3, 7, dwarf::DW_OP_deref);
1613
1614 #undef EXPECT_VALID
1615 #undef EXPECT_INVALID
1616 }
1617
1618 typedef MetadataTest MDObjCPropertyTest;
1619
1620 TEST_F(MDObjCPropertyTest, get) {
1621   StringRef Name = "name";
1622   Metadata *File = MDTuple::getDistinct(Context, None);
1623   unsigned Line = 5;
1624   StringRef GetterName = "getter";
1625   StringRef SetterName = "setter";
1626   unsigned Attributes = 7;
1627   Metadata *Type = MDTuple::getDistinct(Context, None);
1628
1629   auto *N = MDObjCProperty::get(Context, Name, File, Line, GetterName,
1630                                 SetterName, Attributes, Type);
1631
1632   EXPECT_EQ(dwarf::DW_TAG_APPLE_property, N->getTag());
1633   EXPECT_EQ(Name, N->getName());
1634   EXPECT_EQ(File, N->getFile());
1635   EXPECT_EQ(Line, N->getLine());
1636   EXPECT_EQ(GetterName, N->getGetterName());
1637   EXPECT_EQ(SetterName, N->getSetterName());
1638   EXPECT_EQ(Attributes, N->getAttributes());
1639   EXPECT_EQ(Type, N->getType());
1640   EXPECT_EQ(N, MDObjCProperty::get(Context, Name, File, Line, GetterName,
1641                                    SetterName, Attributes, Type));
1642
1643   EXPECT_NE(N, MDObjCProperty::get(Context, "other", File, Line, GetterName,
1644                                    SetterName, Attributes, Type));
1645   EXPECT_NE(N, MDObjCProperty::get(Context, Name, Type, Line, GetterName,
1646                                    SetterName, Attributes, Type));
1647   EXPECT_NE(N, MDObjCProperty::get(Context, Name, File, Line + 1, GetterName,
1648                                    SetterName, Attributes, Type));
1649   EXPECT_NE(N, MDObjCProperty::get(Context, Name, File, Line, "other",
1650                                    SetterName, Attributes, Type));
1651   EXPECT_NE(N, MDObjCProperty::get(Context, Name, File, Line, GetterName,
1652                                    "other", Attributes, Type));
1653   EXPECT_NE(N, MDObjCProperty::get(Context, Name, File, Line, GetterName,
1654                                    SetterName, Attributes + 1, Type));
1655   EXPECT_NE(N, MDObjCProperty::get(Context, Name, File, Line, GetterName,
1656                                    SetterName, Attributes, File));
1657
1658   TempMDObjCProperty Temp = N->clone();
1659   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1660 }
1661
1662 typedef MetadataTest MDImportedEntityTest;
1663
1664 TEST_F(MDImportedEntityTest, get) {
1665   unsigned Tag = dwarf::DW_TAG_imported_module;
1666   Metadata *Scope = MDTuple::getDistinct(Context, None);
1667   Metadata *Entity = MDTuple::getDistinct(Context, None);
1668   unsigned Line = 5;
1669   StringRef Name = "name";
1670
1671   auto *N = MDImportedEntity::get(Context, Tag, Scope, Entity, Line, Name);
1672
1673   EXPECT_EQ(Tag, N->getTag());
1674   EXPECT_EQ(Scope, N->getScope());
1675   EXPECT_EQ(Entity, N->getEntity());
1676   EXPECT_EQ(Line, N->getLine());
1677   EXPECT_EQ(Name, N->getName());
1678   EXPECT_EQ(N, MDImportedEntity::get(Context, Tag, Scope, Entity, Line, Name));
1679
1680   EXPECT_NE(N,
1681             MDImportedEntity::get(Context, dwarf::DW_TAG_imported_declaration,
1682                                   Scope, Entity, Line, Name));
1683   EXPECT_NE(N, MDImportedEntity::get(Context, Tag, Entity, Entity, Line, Name));
1684   EXPECT_NE(N, MDImportedEntity::get(Context, Tag, Scope, Scope, Line, Name));
1685   EXPECT_NE(N,
1686             MDImportedEntity::get(Context, Tag, Scope, Entity, Line + 1, Name));
1687   EXPECT_NE(N,
1688             MDImportedEntity::get(Context, Tag, Scope, Entity, Line, "other"));
1689
1690   TempMDImportedEntity Temp = N->clone();
1691   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
1692 }
1693
1694 typedef MetadataTest MetadataAsValueTest;
1695
1696 TEST_F(MetadataAsValueTest, MDNode) {
1697   MDNode *N = MDNode::get(Context, None);
1698   auto *V = MetadataAsValue::get(Context, N);
1699   EXPECT_TRUE(V->getType()->isMetadataTy());
1700   EXPECT_EQ(N, V->getMetadata());
1701
1702   auto *V2 = MetadataAsValue::get(Context, N);
1703   EXPECT_EQ(V, V2);
1704 }
1705
1706 TEST_F(MetadataAsValueTest, MDNodeMDNode) {
1707   MDNode *N = MDNode::get(Context, None);
1708   Metadata *Ops[] = {N};
1709   MDNode *N2 = MDNode::get(Context, Ops);
1710   auto *V = MetadataAsValue::get(Context, N2);
1711   EXPECT_TRUE(V->getType()->isMetadataTy());
1712   EXPECT_EQ(N2, V->getMetadata());
1713
1714   auto *V2 = MetadataAsValue::get(Context, N2);
1715   EXPECT_EQ(V, V2);
1716
1717   auto *V3 = MetadataAsValue::get(Context, N);
1718   EXPECT_TRUE(V3->getType()->isMetadataTy());
1719   EXPECT_NE(V, V3);
1720   EXPECT_EQ(N, V3->getMetadata());
1721 }
1722
1723 TEST_F(MetadataAsValueTest, MDNodeConstant) {
1724   auto *C = ConstantInt::getTrue(Context);
1725   auto *MD = ConstantAsMetadata::get(C);
1726   Metadata *Ops[] = {MD};
1727   auto *N = MDNode::get(Context, Ops);
1728
1729   auto *V = MetadataAsValue::get(Context, MD);
1730   EXPECT_TRUE(V->getType()->isMetadataTy());
1731   EXPECT_EQ(MD, V->getMetadata());
1732
1733   auto *V2 = MetadataAsValue::get(Context, N);
1734   EXPECT_EQ(MD, V2->getMetadata());
1735   EXPECT_EQ(V, V2);
1736 }
1737
1738 typedef MetadataTest ValueAsMetadataTest;
1739
1740 TEST_F(ValueAsMetadataTest, UpdatesOnRAUW) {
1741   Type *Ty = Type::getInt1PtrTy(Context);
1742   std::unique_ptr<GlobalVariable> GV0(
1743       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
1744   auto *MD = ValueAsMetadata::get(GV0.get());
1745   EXPECT_TRUE(MD->getValue() == GV0.get());
1746   ASSERT_TRUE(GV0->use_empty());
1747
1748   std::unique_ptr<GlobalVariable> GV1(
1749       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
1750   GV0->replaceAllUsesWith(GV1.get());
1751   EXPECT_TRUE(MD->getValue() == GV1.get());
1752 }
1753
1754 TEST_F(ValueAsMetadataTest, CollidingDoubleUpdates) {
1755   // Create a constant.
1756   ConstantAsMetadata *CI = ConstantAsMetadata::get(
1757       ConstantInt::get(getGlobalContext(), APInt(8, 0)));
1758
1759   // Create a temporary to prevent nodes from resolving.
1760   auto Temp = MDTuple::getTemporary(Context, None);
1761
1762   // When the first operand of N1 gets reset to nullptr, it'll collide with N2.
1763   Metadata *Ops1[] = {CI, CI, Temp.get()};
1764   Metadata *Ops2[] = {nullptr, CI, Temp.get()};
1765
1766   auto *N1 = MDTuple::get(Context, Ops1);
1767   auto *N2 = MDTuple::get(Context, Ops2);
1768   ASSERT_NE(N1, N2);
1769
1770   // Tell metadata that the constant is getting deleted.
1771   //
1772   // After this, N1 will be invalid, so don't touch it.
1773   ValueAsMetadata::handleDeletion(CI->getValue());
1774   EXPECT_EQ(nullptr, N2->getOperand(0));
1775   EXPECT_EQ(nullptr, N2->getOperand(1));
1776   EXPECT_EQ(Temp.get(), N2->getOperand(2));
1777
1778   // Clean up Temp for teardown.
1779   Temp->replaceAllUsesWith(nullptr);
1780 }
1781
1782 typedef MetadataTest TrackingMDRefTest;
1783
1784 TEST_F(TrackingMDRefTest, UpdatesOnRAUW) {
1785   Type *Ty = Type::getInt1PtrTy(Context);
1786   std::unique_ptr<GlobalVariable> GV0(
1787       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
1788   TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV0.get()));
1789   EXPECT_TRUE(MD->getValue() == GV0.get());
1790   ASSERT_TRUE(GV0->use_empty());
1791
1792   std::unique_ptr<GlobalVariable> GV1(
1793       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
1794   GV0->replaceAllUsesWith(GV1.get());
1795   EXPECT_TRUE(MD->getValue() == GV1.get());
1796
1797   // Reset it, so we don't inadvertently test deletion.
1798   MD.reset();
1799 }
1800
1801 TEST_F(TrackingMDRefTest, UpdatesOnDeletion) {
1802   Type *Ty = Type::getInt1PtrTy(Context);
1803   std::unique_ptr<GlobalVariable> GV(
1804       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
1805   TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV.get()));
1806   EXPECT_TRUE(MD->getValue() == GV.get());
1807   ASSERT_TRUE(GV->use_empty());
1808
1809   GV.reset();
1810   EXPECT_TRUE(!MD);
1811 }
1812
1813 TEST(NamedMDNodeTest, Search) {
1814   LLVMContext Context;
1815   ConstantAsMetadata *C =
1816       ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 1));
1817   ConstantAsMetadata *C2 =
1818       ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 2));
1819
1820   Metadata *const V = C;
1821   Metadata *const V2 = C2;
1822   MDNode *n = MDNode::get(Context, V);
1823   MDNode *n2 = MDNode::get(Context, V2);
1824
1825   Module M("MyModule", Context);
1826   const char *Name = "llvm.NMD1";
1827   NamedMDNode *NMD = M.getOrInsertNamedMetadata(Name);
1828   NMD->addOperand(n);
1829   NMD->addOperand(n2);
1830
1831   std::string Str;
1832   raw_string_ostream oss(Str);
1833   NMD->print(oss);
1834   EXPECT_STREQ("!llvm.NMD1 = !{!0, !1}\n",
1835                oss.str().c_str());
1836 }
1837 }