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