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