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