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