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