1 //===- DebugInfoMetadata.cpp - Implement debug info metadata --------------===// 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 // This file implements the debug info Metadata classes. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/IR/DebugInfoMetadata.h" 14 #include "LLVMContextImpl.h" 15 #include "MetadataImpl.h" 16 #include "llvm/ADT/SmallSet.h" 17 #include "llvm/ADT/StringSwitch.h" 18 #include "llvm/IR/DIBuilder.h" 19 #include "llvm/IR/Function.h" 20 #include "llvm/IR/Instructions.h" 21 22 #include <numeric> 23 24 using namespace llvm; 25 26 const DIExpression::FragmentInfo DebugVariable::DefaultFragment = { 27 std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::min()}; 28 29 DILocation::DILocation(LLVMContext &C, StorageType Storage, unsigned Line, 30 unsigned Column, ArrayRef<Metadata *> MDs, 31 bool ImplicitCode) 32 : MDNode(C, DILocationKind, Storage, MDs) { 33 assert((MDs.size() == 1 || MDs.size() == 2) && 34 "Expected a scope and optional inlined-at"); 35 36 // Set line and column. 37 assert(Column < (1u << 16) && "Expected 16-bit column"); 38 39 SubclassData32 = Line; 40 SubclassData16 = Column; 41 42 setImplicitCode(ImplicitCode); 43 } 44 45 static void adjustColumn(unsigned &Column) { 46 // Set to unknown on overflow. We only have 16 bits to play with here. 47 if (Column >= (1u << 16)) 48 Column = 0; 49 } 50 51 DILocation *DILocation::getImpl(LLVMContext &Context, unsigned Line, 52 unsigned Column, Metadata *Scope, 53 Metadata *InlinedAt, bool ImplicitCode, 54 StorageType Storage, bool ShouldCreate) { 55 // Fixup column. 56 adjustColumn(Column); 57 58 if (Storage == Uniqued) { 59 if (auto *N = getUniqued(Context.pImpl->DILocations, 60 DILocationInfo::KeyTy(Line, Column, Scope, 61 InlinedAt, ImplicitCode))) 62 return N; 63 if (!ShouldCreate) 64 return nullptr; 65 } else { 66 assert(ShouldCreate && "Expected non-uniqued nodes to always be created"); 67 } 68 69 SmallVector<Metadata *, 2> Ops; 70 Ops.push_back(Scope); 71 if (InlinedAt) 72 Ops.push_back(InlinedAt); 73 return storeImpl(new (Ops.size()) DILocation(Context, Storage, Line, Column, 74 Ops, ImplicitCode), 75 Storage, Context.pImpl->DILocations); 76 } 77 78 const 79 DILocation *DILocation::getMergedLocations(ArrayRef<const DILocation *> Locs) { 80 if (Locs.empty()) 81 return nullptr; 82 if (Locs.size() == 1) 83 return Locs[0]; 84 auto *Merged = Locs[0]; 85 for (auto I = std::next(Locs.begin()), E = Locs.end(); I != E; ++I) { 86 Merged = getMergedLocation(Merged, *I); 87 if (Merged == nullptr) 88 break; 89 } 90 return Merged; 91 } 92 93 const DILocation *DILocation::getMergedLocation(const DILocation *LocA, 94 const DILocation *LocB) { 95 if (!LocA || !LocB) 96 return nullptr; 97 98 if (LocA == LocB) 99 return LocA; 100 101 SmallPtrSet<DILocation *, 5> InlinedLocationsA; 102 for (DILocation *L = LocA->getInlinedAt(); L; L = L->getInlinedAt()) 103 InlinedLocationsA.insert(L); 104 SmallSet<std::pair<DIScope *, DILocation *>, 5> Locations; 105 DIScope *S = LocA->getScope(); 106 DILocation *L = LocA->getInlinedAt(); 107 while (S) { 108 Locations.insert(std::make_pair(S, L)); 109 S = S->getScope(); 110 if (!S && L) { 111 S = L->getScope(); 112 L = L->getInlinedAt(); 113 } 114 } 115 const DILocation *Result = LocB; 116 S = LocB->getScope(); 117 L = LocB->getInlinedAt(); 118 while (S) { 119 if (Locations.count(std::make_pair(S, L))) 120 break; 121 S = S->getScope(); 122 if (!S && L) { 123 S = L->getScope(); 124 L = L->getInlinedAt(); 125 } 126 } 127 128 // If the two locations are irreconsilable, just pick one. This is misleading, 129 // but on the other hand, it's a "line 0" location. 130 if (!S || !isa<DILocalScope>(S)) 131 S = LocA->getScope(); 132 return DILocation::get(Result->getContext(), 0, 0, S, L); 133 } 134 135 Optional<unsigned> DILocation::encodeDiscriminator(unsigned BD, unsigned DF, unsigned CI) { 136 std::array<unsigned, 3> Components = {BD, DF, CI}; 137 uint64_t RemainingWork = 0U; 138 // We use RemainingWork to figure out if we have no remaining components to 139 // encode. For example: if BD != 0 but DF == 0 && CI == 0, we don't need to 140 // encode anything for the latter 2. 141 // Since any of the input components is at most 32 bits, their sum will be 142 // less than 34 bits, and thus RemainingWork won't overflow. 143 RemainingWork = std::accumulate(Components.begin(), Components.end(), RemainingWork); 144 145 int I = 0; 146 unsigned Ret = 0; 147 unsigned NextBitInsertionIndex = 0; 148 while (RemainingWork > 0) { 149 unsigned C = Components[I++]; 150 RemainingWork -= C; 151 unsigned EC = encodeComponent(C); 152 Ret |= (EC << NextBitInsertionIndex); 153 NextBitInsertionIndex += encodingBits(C); 154 } 155 156 // Encoding may be unsuccessful because of overflow. We determine success by 157 // checking equivalence of components before & after encoding. Alternatively, 158 // we could determine Success during encoding, but the current alternative is 159 // simpler. 160 unsigned TBD, TDF, TCI = 0; 161 decodeDiscriminator(Ret, TBD, TDF, TCI); 162 if (TBD == BD && TDF == DF && TCI == CI) 163 return Ret; 164 return None; 165 } 166 167 void DILocation::decodeDiscriminator(unsigned D, unsigned &BD, unsigned &DF, 168 unsigned &CI) { 169 BD = getUnsignedFromPrefixEncoding(D); 170 DF = getUnsignedFromPrefixEncoding(getNextComponentInDiscriminator(D)); 171 CI = getUnsignedFromPrefixEncoding( 172 getNextComponentInDiscriminator(getNextComponentInDiscriminator(D))); 173 } 174 175 176 DINode::DIFlags DINode::getFlag(StringRef Flag) { 177 return StringSwitch<DIFlags>(Flag) 178 #define HANDLE_DI_FLAG(ID, NAME) .Case("DIFlag" #NAME, Flag##NAME) 179 #include "llvm/IR/DebugInfoFlags.def" 180 .Default(DINode::FlagZero); 181 } 182 183 StringRef DINode::getFlagString(DIFlags Flag) { 184 switch (Flag) { 185 #define HANDLE_DI_FLAG(ID, NAME) \ 186 case Flag##NAME: \ 187 return "DIFlag" #NAME; 188 #include "llvm/IR/DebugInfoFlags.def" 189 } 190 return ""; 191 } 192 193 DINode::DIFlags DINode::splitFlags(DIFlags Flags, 194 SmallVectorImpl<DIFlags> &SplitFlags) { 195 // Flags that are packed together need to be specially handled, so 196 // that, for example, we emit "DIFlagPublic" and not 197 // "DIFlagPrivate | DIFlagProtected". 198 if (DIFlags A = Flags & FlagAccessibility) { 199 if (A == FlagPrivate) 200 SplitFlags.push_back(FlagPrivate); 201 else if (A == FlagProtected) 202 SplitFlags.push_back(FlagProtected); 203 else 204 SplitFlags.push_back(FlagPublic); 205 Flags &= ~A; 206 } 207 if (DIFlags R = Flags & FlagPtrToMemberRep) { 208 if (R == FlagSingleInheritance) 209 SplitFlags.push_back(FlagSingleInheritance); 210 else if (R == FlagMultipleInheritance) 211 SplitFlags.push_back(FlagMultipleInheritance); 212 else 213 SplitFlags.push_back(FlagVirtualInheritance); 214 Flags &= ~R; 215 } 216 if ((Flags & FlagIndirectVirtualBase) == FlagIndirectVirtualBase) { 217 Flags &= ~FlagIndirectVirtualBase; 218 SplitFlags.push_back(FlagIndirectVirtualBase); 219 } 220 221 #define HANDLE_DI_FLAG(ID, NAME) \ 222 if (DIFlags Bit = Flags & Flag##NAME) { \ 223 SplitFlags.push_back(Bit); \ 224 Flags &= ~Bit; \ 225 } 226 #include "llvm/IR/DebugInfoFlags.def" 227 return Flags; 228 } 229 230 DIScope *DIScope::getScope() const { 231 if (auto *T = dyn_cast<DIType>(this)) 232 return T->getScope(); 233 234 if (auto *SP = dyn_cast<DISubprogram>(this)) 235 return SP->getScope(); 236 237 if (auto *LB = dyn_cast<DILexicalBlockBase>(this)) 238 return LB->getScope(); 239 240 if (auto *NS = dyn_cast<DINamespace>(this)) 241 return NS->getScope(); 242 243 if (auto *CB = dyn_cast<DICommonBlock>(this)) 244 return CB->getScope(); 245 246 if (auto *M = dyn_cast<DIModule>(this)) 247 return M->getScope(); 248 249 assert((isa<DIFile>(this) || isa<DICompileUnit>(this)) && 250 "Unhandled type of scope."); 251 return nullptr; 252 } 253 254 StringRef DIScope::getName() const { 255 if (auto *T = dyn_cast<DIType>(this)) 256 return T->getName(); 257 if (auto *SP = dyn_cast<DISubprogram>(this)) 258 return SP->getName(); 259 if (auto *NS = dyn_cast<DINamespace>(this)) 260 return NS->getName(); 261 if (auto *CB = dyn_cast<DICommonBlock>(this)) 262 return CB->getName(); 263 if (auto *M = dyn_cast<DIModule>(this)) 264 return M->getName(); 265 assert((isa<DILexicalBlockBase>(this) || isa<DIFile>(this) || 266 isa<DICompileUnit>(this)) && 267 "Unhandled type of scope."); 268 return ""; 269 } 270 271 #ifndef NDEBUG 272 static bool isCanonical(const MDString *S) { 273 return !S || !S->getString().empty(); 274 } 275 #endif 276 277 GenericDINode *GenericDINode::getImpl(LLVMContext &Context, unsigned Tag, 278 MDString *Header, 279 ArrayRef<Metadata *> DwarfOps, 280 StorageType Storage, bool ShouldCreate) { 281 unsigned Hash = 0; 282 if (Storage == Uniqued) { 283 GenericDINodeInfo::KeyTy Key(Tag, Header, DwarfOps); 284 if (auto *N = getUniqued(Context.pImpl->GenericDINodes, Key)) 285 return N; 286 if (!ShouldCreate) 287 return nullptr; 288 Hash = Key.getHash(); 289 } else { 290 assert(ShouldCreate && "Expected non-uniqued nodes to always be created"); 291 } 292 293 // Use a nullptr for empty headers. 294 assert(isCanonical(Header) && "Expected canonical MDString"); 295 Metadata *PreOps[] = {Header}; 296 return storeImpl(new (DwarfOps.size() + 1) GenericDINode( 297 Context, Storage, Hash, Tag, PreOps, DwarfOps), 298 Storage, Context.pImpl->GenericDINodes); 299 } 300 301 void GenericDINode::recalculateHash() { 302 setHash(GenericDINodeInfo::KeyTy::calculateHash(this)); 303 } 304 305 #define UNWRAP_ARGS_IMPL(...) __VA_ARGS__ 306 #define UNWRAP_ARGS(ARGS) UNWRAP_ARGS_IMPL ARGS 307 #define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS) \ 308 do { \ 309 if (Storage == Uniqued) { \ 310 if (auto *N = getUniqued(Context.pImpl->CLASS##s, \ 311 CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS)))) \ 312 return N; \ 313 if (!ShouldCreate) \ 314 return nullptr; \ 315 } else { \ 316 assert(ShouldCreate && \ 317 "Expected non-uniqued nodes to always be created"); \ 318 } \ 319 } while (false) 320 #define DEFINE_GETIMPL_STORE(CLASS, ARGS, OPS) \ 321 return storeImpl(new (array_lengthof(OPS)) \ 322 CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \ 323 Storage, Context.pImpl->CLASS##s) 324 #define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS) \ 325 return storeImpl(new (0u) CLASS(Context, Storage, UNWRAP_ARGS(ARGS)), \ 326 Storage, Context.pImpl->CLASS##s) 327 #define DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(CLASS, OPS) \ 328 return storeImpl(new (array_lengthof(OPS)) CLASS(Context, Storage, OPS), \ 329 Storage, Context.pImpl->CLASS##s) 330 #define DEFINE_GETIMPL_STORE_N(CLASS, ARGS, OPS, NUM_OPS) \ 331 return storeImpl(new (NUM_OPS) \ 332 CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \ 333 Storage, Context.pImpl->CLASS##s) 334 335 DISubrange *DISubrange::getImpl(LLVMContext &Context, int64_t Count, int64_t Lo, 336 StorageType Storage, bool ShouldCreate) { 337 auto *CountNode = ConstantAsMetadata::get( 338 ConstantInt::getSigned(Type::getInt64Ty(Context), Count)); 339 auto *LB = ConstantAsMetadata::get( 340 ConstantInt::getSigned(Type::getInt64Ty(Context), Lo)); 341 return getImpl(Context, CountNode, LB, nullptr, nullptr, Storage, 342 ShouldCreate); 343 } 344 345 DISubrange *DISubrange::getImpl(LLVMContext &Context, Metadata *CountNode, 346 int64_t Lo, StorageType Storage, 347 bool ShouldCreate) { 348 auto *LB = ConstantAsMetadata::get( 349 ConstantInt::getSigned(Type::getInt64Ty(Context), Lo)); 350 return getImpl(Context, CountNode, LB, nullptr, nullptr, Storage, 351 ShouldCreate); 352 } 353 354 DISubrange *DISubrange::getImpl(LLVMContext &Context, Metadata *CountNode, 355 Metadata *LB, Metadata *UB, Metadata *Stride, 356 StorageType Storage, bool ShouldCreate) { 357 DEFINE_GETIMPL_LOOKUP(DISubrange, (CountNode, LB, UB, Stride)); 358 Metadata *Ops[] = {CountNode, LB, UB, Stride}; 359 DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DISubrange, Ops); 360 } 361 362 DISubrange::CountType DISubrange::getCount() const { 363 if (!getRawCountNode()) 364 return CountType(); 365 366 if (auto *MD = dyn_cast<ConstantAsMetadata>(getRawCountNode())) 367 return CountType(cast<ConstantInt>(MD->getValue())); 368 369 if (auto *DV = dyn_cast<DIVariable>(getRawCountNode())) 370 return CountType(DV); 371 372 return CountType(); 373 } 374 375 DISubrange::BoundType DISubrange::getLowerBound() const { 376 Metadata *LB = getRawLowerBound(); 377 if (!LB) 378 return BoundType(); 379 380 assert((isa<ConstantAsMetadata>(LB) || isa<DIVariable>(LB) || 381 isa<DIExpression>(LB)) && 382 "LowerBound must be signed constant or DIVariable or DIExpression"); 383 384 if (auto *MD = dyn_cast<ConstantAsMetadata>(LB)) 385 return BoundType(cast<ConstantInt>(MD->getValue())); 386 387 if (auto *MD = dyn_cast<DIVariable>(LB)) 388 return BoundType(MD); 389 390 if (auto *MD = dyn_cast<DIExpression>(LB)) 391 return BoundType(MD); 392 393 return BoundType(); 394 } 395 396 DISubrange::BoundType DISubrange::getUpperBound() const { 397 Metadata *UB = getRawUpperBound(); 398 if (!UB) 399 return BoundType(); 400 401 assert((isa<ConstantAsMetadata>(UB) || isa<DIVariable>(UB) || 402 isa<DIExpression>(UB)) && 403 "UpperBound must be signed constant or DIVariable or DIExpression"); 404 405 if (auto *MD = dyn_cast<ConstantAsMetadata>(UB)) 406 return BoundType(cast<ConstantInt>(MD->getValue())); 407 408 if (auto *MD = dyn_cast<DIVariable>(UB)) 409 return BoundType(MD); 410 411 if (auto *MD = dyn_cast<DIExpression>(UB)) 412 return BoundType(MD); 413 414 return BoundType(); 415 } 416 417 DISubrange::BoundType DISubrange::getStride() const { 418 Metadata *ST = getRawStride(); 419 if (!ST) 420 return BoundType(); 421 422 assert((isa<ConstantAsMetadata>(ST) || isa<DIVariable>(ST) || 423 isa<DIExpression>(ST)) && 424 "Stride must be signed constant or DIVariable or DIExpression"); 425 426 if (auto *MD = dyn_cast<ConstantAsMetadata>(ST)) 427 return BoundType(cast<ConstantInt>(MD->getValue())); 428 429 if (auto *MD = dyn_cast<DIVariable>(ST)) 430 return BoundType(MD); 431 432 if (auto *MD = dyn_cast<DIExpression>(ST)) 433 return BoundType(MD); 434 435 return BoundType(); 436 } 437 438 DIGenericSubrange *DIGenericSubrange::getImpl(LLVMContext &Context, 439 Metadata *CountNode, Metadata *LB, 440 Metadata *UB, Metadata *Stride, 441 StorageType Storage, 442 bool ShouldCreate) { 443 DEFINE_GETIMPL_LOOKUP(DIGenericSubrange, (CountNode, LB, UB, Stride)); 444 Metadata *Ops[] = {CountNode, LB, UB, Stride}; 445 DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIGenericSubrange, Ops); 446 } 447 448 DIGenericSubrange::BoundType DIGenericSubrange::getCount() const { 449 Metadata *CB = getRawCountNode(); 450 if (!CB) 451 return BoundType(); 452 453 assert((isa<DIVariable>(CB) || isa<DIExpression>(CB)) && 454 "Count must be signed constant or DIVariable or DIExpression"); 455 456 if (auto *MD = dyn_cast<DIVariable>(CB)) 457 return BoundType(MD); 458 459 if (auto *MD = dyn_cast<DIExpression>(CB)) 460 return BoundType(MD); 461 462 return BoundType(); 463 } 464 465 DIGenericSubrange::BoundType DIGenericSubrange::getLowerBound() const { 466 Metadata *LB = getRawLowerBound(); 467 if (!LB) 468 return BoundType(); 469 470 assert((isa<DIVariable>(LB) || isa<DIExpression>(LB)) && 471 "LowerBound must be signed constant or DIVariable or DIExpression"); 472 473 if (auto *MD = dyn_cast<DIVariable>(LB)) 474 return BoundType(MD); 475 476 if (auto *MD = dyn_cast<DIExpression>(LB)) 477 return BoundType(MD); 478 479 return BoundType(); 480 } 481 482 DIGenericSubrange::BoundType DIGenericSubrange::getUpperBound() const { 483 Metadata *UB = getRawUpperBound(); 484 if (!UB) 485 return BoundType(); 486 487 assert((isa<DIVariable>(UB) || isa<DIExpression>(UB)) && 488 "UpperBound must be signed constant or DIVariable or DIExpression"); 489 490 if (auto *MD = dyn_cast<DIVariable>(UB)) 491 return BoundType(MD); 492 493 if (auto *MD = dyn_cast<DIExpression>(UB)) 494 return BoundType(MD); 495 496 return BoundType(); 497 } 498 499 DIGenericSubrange::BoundType DIGenericSubrange::getStride() const { 500 Metadata *ST = getRawStride(); 501 if (!ST) 502 return BoundType(); 503 504 assert((isa<DIVariable>(ST) || isa<DIExpression>(ST)) && 505 "Stride must be signed constant or DIVariable or DIExpression"); 506 507 if (auto *MD = dyn_cast<DIVariable>(ST)) 508 return BoundType(MD); 509 510 if (auto *MD = dyn_cast<DIExpression>(ST)) 511 return BoundType(MD); 512 513 return BoundType(); 514 } 515 516 DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, const APInt &Value, 517 bool IsUnsigned, MDString *Name, 518 StorageType Storage, bool ShouldCreate) { 519 assert(isCanonical(Name) && "Expected canonical MDString"); 520 DEFINE_GETIMPL_LOOKUP(DIEnumerator, (Value, IsUnsigned, Name)); 521 Metadata *Ops[] = {Name}; 522 DEFINE_GETIMPL_STORE(DIEnumerator, (Value, IsUnsigned), Ops); 523 } 524 525 DIBasicType *DIBasicType::getImpl(LLVMContext &Context, unsigned Tag, 526 MDString *Name, uint64_t SizeInBits, 527 uint32_t AlignInBits, unsigned Encoding, 528 DIFlags Flags, StorageType Storage, 529 bool ShouldCreate) { 530 assert(isCanonical(Name) && "Expected canonical MDString"); 531 DEFINE_GETIMPL_LOOKUP(DIBasicType, 532 (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags)); 533 Metadata *Ops[] = {nullptr, nullptr, Name}; 534 DEFINE_GETIMPL_STORE(DIBasicType, (Tag, SizeInBits, AlignInBits, Encoding, 535 Flags), Ops); 536 } 537 538 Optional<DIBasicType::Signedness> DIBasicType::getSignedness() const { 539 switch (getEncoding()) { 540 case dwarf::DW_ATE_signed: 541 case dwarf::DW_ATE_signed_char: 542 return Signedness::Signed; 543 case dwarf::DW_ATE_unsigned: 544 case dwarf::DW_ATE_unsigned_char: 545 return Signedness::Unsigned; 546 default: 547 return None; 548 } 549 } 550 551 DIStringType *DIStringType::getImpl(LLVMContext &Context, unsigned Tag, 552 MDString *Name, Metadata *StringLength, 553 Metadata *StringLengthExp, 554 uint64_t SizeInBits, uint32_t AlignInBits, 555 unsigned Encoding, StorageType Storage, 556 bool ShouldCreate) { 557 assert(isCanonical(Name) && "Expected canonical MDString"); 558 DEFINE_GETIMPL_LOOKUP(DIStringType, (Tag, Name, StringLength, StringLengthExp, 559 SizeInBits, AlignInBits, Encoding)); 560 Metadata *Ops[] = {nullptr, nullptr, Name, StringLength, StringLengthExp}; 561 DEFINE_GETIMPL_STORE(DIStringType, (Tag, SizeInBits, AlignInBits, Encoding), 562 Ops); 563 } 564 565 DIDerivedType *DIDerivedType::getImpl( 566 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File, 567 unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, 568 uint32_t AlignInBits, uint64_t OffsetInBits, 569 Optional<unsigned> DWARFAddressSpace, DIFlags Flags, Metadata *ExtraData, 570 StorageType Storage, bool ShouldCreate) { 571 assert(isCanonical(Name) && "Expected canonical MDString"); 572 DEFINE_GETIMPL_LOOKUP(DIDerivedType, 573 (Tag, Name, File, Line, Scope, BaseType, SizeInBits, 574 AlignInBits, OffsetInBits, DWARFAddressSpace, Flags, 575 ExtraData)); 576 Metadata *Ops[] = {File, Scope, Name, BaseType, ExtraData}; 577 DEFINE_GETIMPL_STORE( 578 DIDerivedType, (Tag, Line, SizeInBits, AlignInBits, OffsetInBits, 579 DWARFAddressSpace, Flags), Ops); 580 } 581 582 DICompositeType *DICompositeType::getImpl( 583 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File, 584 unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, 585 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags, 586 Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder, 587 Metadata *TemplateParams, MDString *Identifier, Metadata *Discriminator, 588 Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, 589 Metadata *Rank, StorageType Storage, bool ShouldCreate) { 590 assert(isCanonical(Name) && "Expected canonical MDString"); 591 592 // Keep this in sync with buildODRType. 593 DEFINE_GETIMPL_LOOKUP( 594 DICompositeType, 595 (Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits, 596 OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams, 597 Identifier, Discriminator, DataLocation, Associated, Allocated, Rank)); 598 Metadata *Ops[] = {File, Scope, Name, BaseType, 599 Elements, VTableHolder, TemplateParams, Identifier, 600 Discriminator, DataLocation, Associated, Allocated, 601 Rank}; 602 DEFINE_GETIMPL_STORE(DICompositeType, (Tag, Line, RuntimeLang, SizeInBits, 603 AlignInBits, OffsetInBits, Flags), 604 Ops); 605 } 606 607 DICompositeType *DICompositeType::buildODRType( 608 LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name, 609 Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, 610 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, 611 DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, 612 Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator, 613 Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, 614 Metadata *Rank) { 615 assert(!Identifier.getString().empty() && "Expected valid identifier"); 616 if (!Context.isODRUniquingDebugTypes()) 617 return nullptr; 618 auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier]; 619 if (!CT) 620 return CT = DICompositeType::getDistinct( 621 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, 622 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, 623 VTableHolder, TemplateParams, &Identifier, Discriminator, 624 DataLocation, Associated, Allocated, Rank); 625 626 // Only mutate CT if it's a forward declaration and the new operands aren't. 627 assert(CT->getRawIdentifier() == &Identifier && "Wrong ODR identifier?"); 628 if (!CT->isForwardDecl() || (Flags & DINode::FlagFwdDecl)) 629 return CT; 630 631 // Mutate CT in place. Keep this in sync with getImpl. 632 CT->mutate(Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits, 633 Flags); 634 Metadata *Ops[] = {File, Scope, Name, BaseType, 635 Elements, VTableHolder, TemplateParams, &Identifier, 636 Discriminator, DataLocation, Associated, Allocated, 637 Rank}; 638 assert((std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() && 639 "Mismatched number of operands"); 640 for (unsigned I = 0, E = CT->getNumOperands(); I != E; ++I) 641 if (Ops[I] != CT->getOperand(I)) 642 CT->setOperand(I, Ops[I]); 643 return CT; 644 } 645 646 DICompositeType *DICompositeType::getODRType( 647 LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name, 648 Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, 649 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, 650 DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, 651 Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator, 652 Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, 653 Metadata *Rank) { 654 assert(!Identifier.getString().empty() && "Expected valid identifier"); 655 if (!Context.isODRUniquingDebugTypes()) 656 return nullptr; 657 auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier]; 658 if (!CT) 659 CT = DICompositeType::getDistinct( 660 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, 661 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder, 662 TemplateParams, &Identifier, Discriminator, DataLocation, Associated, 663 Allocated, Rank); 664 return CT; 665 } 666 667 DICompositeType *DICompositeType::getODRTypeIfExists(LLVMContext &Context, 668 MDString &Identifier) { 669 assert(!Identifier.getString().empty() && "Expected valid identifier"); 670 if (!Context.isODRUniquingDebugTypes()) 671 return nullptr; 672 return Context.pImpl->DITypeMap->lookup(&Identifier); 673 } 674 675 DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context, DIFlags Flags, 676 uint8_t CC, Metadata *TypeArray, 677 StorageType Storage, 678 bool ShouldCreate) { 679 DEFINE_GETIMPL_LOOKUP(DISubroutineType, (Flags, CC, TypeArray)); 680 Metadata *Ops[] = {nullptr, nullptr, nullptr, TypeArray}; 681 DEFINE_GETIMPL_STORE(DISubroutineType, (Flags, CC), Ops); 682 } 683 684 // FIXME: Implement this string-enum correspondence with a .def file and macros, 685 // so that the association is explicit rather than implied. 686 static const char *ChecksumKindName[DIFile::CSK_Last] = { 687 "CSK_MD5", 688 "CSK_SHA1", 689 "CSK_SHA256", 690 }; 691 692 StringRef DIFile::getChecksumKindAsString(ChecksumKind CSKind) { 693 assert(CSKind <= DIFile::CSK_Last && "Invalid checksum kind"); 694 // The first space was originally the CSK_None variant, which is now 695 // obsolete, but the space is still reserved in ChecksumKind, so we account 696 // for it here. 697 return ChecksumKindName[CSKind - 1]; 698 } 699 700 Optional<DIFile::ChecksumKind> DIFile::getChecksumKind(StringRef CSKindStr) { 701 return StringSwitch<Optional<DIFile::ChecksumKind>>(CSKindStr) 702 .Case("CSK_MD5", DIFile::CSK_MD5) 703 .Case("CSK_SHA1", DIFile::CSK_SHA1) 704 .Case("CSK_SHA256", DIFile::CSK_SHA256) 705 .Default(None); 706 } 707 708 DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename, 709 MDString *Directory, 710 Optional<DIFile::ChecksumInfo<MDString *>> CS, 711 Optional<MDString *> Source, StorageType Storage, 712 bool ShouldCreate) { 713 assert(isCanonical(Filename) && "Expected canonical MDString"); 714 assert(isCanonical(Directory) && "Expected canonical MDString"); 715 assert((!CS || isCanonical(CS->Value)) && "Expected canonical MDString"); 716 assert((!Source || isCanonical(*Source)) && "Expected canonical MDString"); 717 DEFINE_GETIMPL_LOOKUP(DIFile, (Filename, Directory, CS, Source)); 718 Metadata *Ops[] = {Filename, Directory, CS ? CS->Value : nullptr, 719 Source.getValueOr(nullptr)}; 720 DEFINE_GETIMPL_STORE(DIFile, (CS, Source), Ops); 721 } 722 723 DICompileUnit *DICompileUnit::getImpl( 724 LLVMContext &Context, unsigned SourceLanguage, Metadata *File, 725 MDString *Producer, bool IsOptimized, MDString *Flags, 726 unsigned RuntimeVersion, MDString *SplitDebugFilename, 727 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes, 728 Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros, 729 uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling, 730 unsigned NameTableKind, bool RangesBaseAddress, MDString *SysRoot, 731 MDString *SDK, StorageType Storage, bool ShouldCreate) { 732 assert(Storage != Uniqued && "Cannot unique DICompileUnit"); 733 assert(isCanonical(Producer) && "Expected canonical MDString"); 734 assert(isCanonical(Flags) && "Expected canonical MDString"); 735 assert(isCanonical(SplitDebugFilename) && "Expected canonical MDString"); 736 737 Metadata *Ops[] = {File, 738 Producer, 739 Flags, 740 SplitDebugFilename, 741 EnumTypes, 742 RetainedTypes, 743 GlobalVariables, 744 ImportedEntities, 745 Macros, 746 SysRoot, 747 SDK}; 748 return storeImpl(new (array_lengthof(Ops)) DICompileUnit( 749 Context, Storage, SourceLanguage, IsOptimized, 750 RuntimeVersion, EmissionKind, DWOId, SplitDebugInlining, 751 DebugInfoForProfiling, NameTableKind, RangesBaseAddress, 752 Ops), 753 Storage); 754 } 755 756 Optional<DICompileUnit::DebugEmissionKind> 757 DICompileUnit::getEmissionKind(StringRef Str) { 758 return StringSwitch<Optional<DebugEmissionKind>>(Str) 759 .Case("NoDebug", NoDebug) 760 .Case("FullDebug", FullDebug) 761 .Case("LineTablesOnly", LineTablesOnly) 762 .Case("DebugDirectivesOnly", DebugDirectivesOnly) 763 .Default(None); 764 } 765 766 Optional<DICompileUnit::DebugNameTableKind> 767 DICompileUnit::getNameTableKind(StringRef Str) { 768 return StringSwitch<Optional<DebugNameTableKind>>(Str) 769 .Case("Default", DebugNameTableKind::Default) 770 .Case("GNU", DebugNameTableKind::GNU) 771 .Case("None", DebugNameTableKind::None) 772 .Default(None); 773 } 774 775 const char *DICompileUnit::emissionKindString(DebugEmissionKind EK) { 776 switch (EK) { 777 case NoDebug: return "NoDebug"; 778 case FullDebug: return "FullDebug"; 779 case LineTablesOnly: return "LineTablesOnly"; 780 case DebugDirectivesOnly: return "DebugDirectivesOnly"; 781 } 782 return nullptr; 783 } 784 785 const char *DICompileUnit::nameTableKindString(DebugNameTableKind NTK) { 786 switch (NTK) { 787 case DebugNameTableKind::Default: 788 return nullptr; 789 case DebugNameTableKind::GNU: 790 return "GNU"; 791 case DebugNameTableKind::None: 792 return "None"; 793 } 794 return nullptr; 795 } 796 797 DISubprogram *DILocalScope::getSubprogram() const { 798 if (auto *Block = dyn_cast<DILexicalBlockBase>(this)) 799 return Block->getScope()->getSubprogram(); 800 return const_cast<DISubprogram *>(cast<DISubprogram>(this)); 801 } 802 803 DILocalScope *DILocalScope::getNonLexicalBlockFileScope() const { 804 if (auto *File = dyn_cast<DILexicalBlockFile>(this)) 805 return File->getScope()->getNonLexicalBlockFileScope(); 806 return const_cast<DILocalScope *>(this); 807 } 808 809 DISubprogram::DISPFlags DISubprogram::getFlag(StringRef Flag) { 810 return StringSwitch<DISPFlags>(Flag) 811 #define HANDLE_DISP_FLAG(ID, NAME) .Case("DISPFlag" #NAME, SPFlag##NAME) 812 #include "llvm/IR/DebugInfoFlags.def" 813 .Default(SPFlagZero); 814 } 815 816 StringRef DISubprogram::getFlagString(DISPFlags Flag) { 817 switch (Flag) { 818 // Appease a warning. 819 case SPFlagVirtuality: 820 return ""; 821 #define HANDLE_DISP_FLAG(ID, NAME) \ 822 case SPFlag##NAME: \ 823 return "DISPFlag" #NAME; 824 #include "llvm/IR/DebugInfoFlags.def" 825 } 826 return ""; 827 } 828 829 DISubprogram::DISPFlags 830 DISubprogram::splitFlags(DISPFlags Flags, 831 SmallVectorImpl<DISPFlags> &SplitFlags) { 832 // Multi-bit fields can require special handling. In our case, however, the 833 // only multi-bit field is virtuality, and all its values happen to be 834 // single-bit values, so the right behavior just falls out. 835 #define HANDLE_DISP_FLAG(ID, NAME) \ 836 if (DISPFlags Bit = Flags & SPFlag##NAME) { \ 837 SplitFlags.push_back(Bit); \ 838 Flags &= ~Bit; \ 839 } 840 #include "llvm/IR/DebugInfoFlags.def" 841 return Flags; 842 } 843 844 DISubprogram *DISubprogram::getImpl( 845 LLVMContext &Context, Metadata *Scope, MDString *Name, 846 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type, 847 unsigned ScopeLine, Metadata *ContainingType, unsigned VirtualIndex, 848 int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags, Metadata *Unit, 849 Metadata *TemplateParams, Metadata *Declaration, Metadata *RetainedNodes, 850 Metadata *ThrownTypes, StorageType Storage, bool ShouldCreate) { 851 assert(isCanonical(Name) && "Expected canonical MDString"); 852 assert(isCanonical(LinkageName) && "Expected canonical MDString"); 853 DEFINE_GETIMPL_LOOKUP(DISubprogram, 854 (Scope, Name, LinkageName, File, Line, Type, ScopeLine, 855 ContainingType, VirtualIndex, ThisAdjustment, Flags, 856 SPFlags, Unit, TemplateParams, Declaration, 857 RetainedNodes, ThrownTypes)); 858 SmallVector<Metadata *, 11> Ops = { 859 File, Scope, Name, LinkageName, Type, Unit, 860 Declaration, RetainedNodes, ContainingType, TemplateParams, ThrownTypes}; 861 if (!ThrownTypes) { 862 Ops.pop_back(); 863 if (!TemplateParams) { 864 Ops.pop_back(); 865 if (!ContainingType) 866 Ops.pop_back(); 867 } 868 } 869 DEFINE_GETIMPL_STORE_N( 870 DISubprogram, 871 (Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags), Ops, 872 Ops.size()); 873 } 874 875 bool DISubprogram::describes(const Function *F) const { 876 assert(F && "Invalid function"); 877 return F->getSubprogram() == this; 878 } 879 880 DILexicalBlock *DILexicalBlock::getImpl(LLVMContext &Context, Metadata *Scope, 881 Metadata *File, unsigned Line, 882 unsigned Column, StorageType Storage, 883 bool ShouldCreate) { 884 // Fixup column. 885 adjustColumn(Column); 886 887 assert(Scope && "Expected scope"); 888 DEFINE_GETIMPL_LOOKUP(DILexicalBlock, (Scope, File, Line, Column)); 889 Metadata *Ops[] = {File, Scope}; 890 DEFINE_GETIMPL_STORE(DILexicalBlock, (Line, Column), Ops); 891 } 892 893 DILexicalBlockFile *DILexicalBlockFile::getImpl(LLVMContext &Context, 894 Metadata *Scope, Metadata *File, 895 unsigned Discriminator, 896 StorageType Storage, 897 bool ShouldCreate) { 898 assert(Scope && "Expected scope"); 899 DEFINE_GETIMPL_LOOKUP(DILexicalBlockFile, (Scope, File, Discriminator)); 900 Metadata *Ops[] = {File, Scope}; 901 DEFINE_GETIMPL_STORE(DILexicalBlockFile, (Discriminator), Ops); 902 } 903 904 DINamespace *DINamespace::getImpl(LLVMContext &Context, Metadata *Scope, 905 MDString *Name, bool ExportSymbols, 906 StorageType Storage, bool ShouldCreate) { 907 assert(isCanonical(Name) && "Expected canonical MDString"); 908 DEFINE_GETIMPL_LOOKUP(DINamespace, (Scope, Name, ExportSymbols)); 909 // The nullptr is for DIScope's File operand. This should be refactored. 910 Metadata *Ops[] = {nullptr, Scope, Name}; 911 DEFINE_GETIMPL_STORE(DINamespace, (ExportSymbols), Ops); 912 } 913 914 DICommonBlock *DICommonBlock::getImpl(LLVMContext &Context, Metadata *Scope, 915 Metadata *Decl, MDString *Name, 916 Metadata *File, unsigned LineNo, 917 StorageType Storage, bool ShouldCreate) { 918 assert(isCanonical(Name) && "Expected canonical MDString"); 919 DEFINE_GETIMPL_LOOKUP(DICommonBlock, (Scope, Decl, Name, File, LineNo)); 920 // The nullptr is for DIScope's File operand. This should be refactored. 921 Metadata *Ops[] = {Scope, Decl, Name, File}; 922 DEFINE_GETIMPL_STORE(DICommonBlock, (LineNo), Ops); 923 } 924 925 DIModule *DIModule::getImpl(LLVMContext &Context, Metadata *File, 926 Metadata *Scope, MDString *Name, 927 MDString *ConfigurationMacros, 928 MDString *IncludePath, MDString *APINotesFile, 929 unsigned LineNo, bool IsDecl, StorageType Storage, 930 bool ShouldCreate) { 931 assert(isCanonical(Name) && "Expected canonical MDString"); 932 DEFINE_GETIMPL_LOOKUP(DIModule, (File, Scope, Name, ConfigurationMacros, 933 IncludePath, APINotesFile, LineNo, IsDecl)); 934 Metadata *Ops[] = {File, Scope, Name, ConfigurationMacros, 935 IncludePath, APINotesFile}; 936 DEFINE_GETIMPL_STORE(DIModule, (LineNo, IsDecl), Ops); 937 } 938 939 DITemplateTypeParameter * 940 DITemplateTypeParameter::getImpl(LLVMContext &Context, MDString *Name, 941 Metadata *Type, bool isDefault, 942 StorageType Storage, bool ShouldCreate) { 943 assert(isCanonical(Name) && "Expected canonical MDString"); 944 DEFINE_GETIMPL_LOOKUP(DITemplateTypeParameter, (Name, Type, isDefault)); 945 Metadata *Ops[] = {Name, Type}; 946 DEFINE_GETIMPL_STORE(DITemplateTypeParameter, (isDefault), Ops); 947 } 948 949 DITemplateValueParameter *DITemplateValueParameter::getImpl( 950 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *Type, 951 bool isDefault, Metadata *Value, StorageType Storage, bool ShouldCreate) { 952 assert(isCanonical(Name) && "Expected canonical MDString"); 953 DEFINE_GETIMPL_LOOKUP(DITemplateValueParameter, 954 (Tag, Name, Type, isDefault, Value)); 955 Metadata *Ops[] = {Name, Type, Value}; 956 DEFINE_GETIMPL_STORE(DITemplateValueParameter, (Tag, isDefault), Ops); 957 } 958 959 DIGlobalVariable * 960 DIGlobalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name, 961 MDString *LinkageName, Metadata *File, unsigned Line, 962 Metadata *Type, bool IsLocalToUnit, bool IsDefinition, 963 Metadata *StaticDataMemberDeclaration, 964 Metadata *TemplateParams, uint32_t AlignInBits, 965 StorageType Storage, bool ShouldCreate) { 966 assert(isCanonical(Name) && "Expected canonical MDString"); 967 assert(isCanonical(LinkageName) && "Expected canonical MDString"); 968 DEFINE_GETIMPL_LOOKUP(DIGlobalVariable, (Scope, Name, LinkageName, File, Line, 969 Type, IsLocalToUnit, IsDefinition, 970 StaticDataMemberDeclaration, 971 TemplateParams, AlignInBits)); 972 Metadata *Ops[] = {Scope, 973 Name, 974 File, 975 Type, 976 Name, 977 LinkageName, 978 StaticDataMemberDeclaration, 979 TemplateParams}; 980 DEFINE_GETIMPL_STORE(DIGlobalVariable, 981 (Line, IsLocalToUnit, IsDefinition, AlignInBits), Ops); 982 } 983 984 DILocalVariable *DILocalVariable::getImpl(LLVMContext &Context, Metadata *Scope, 985 MDString *Name, Metadata *File, 986 unsigned Line, Metadata *Type, 987 unsigned Arg, DIFlags Flags, 988 uint32_t AlignInBits, 989 StorageType Storage, 990 bool ShouldCreate) { 991 // 64K ought to be enough for any frontend. 992 assert(Arg <= UINT16_MAX && "Expected argument number to fit in 16-bits"); 993 994 assert(Scope && "Expected scope"); 995 assert(isCanonical(Name) && "Expected canonical MDString"); 996 DEFINE_GETIMPL_LOOKUP(DILocalVariable, 997 (Scope, Name, File, Line, Type, Arg, Flags, 998 AlignInBits)); 999 Metadata *Ops[] = {Scope, Name, File, Type}; 1000 DEFINE_GETIMPL_STORE(DILocalVariable, (Line, Arg, Flags, AlignInBits), Ops); 1001 } 1002 1003 Optional<uint64_t> DIVariable::getSizeInBits() const { 1004 // This is used by the Verifier so be mindful of broken types. 1005 const Metadata *RawType = getRawType(); 1006 while (RawType) { 1007 // Try to get the size directly. 1008 if (auto *T = dyn_cast<DIType>(RawType)) 1009 if (uint64_t Size = T->getSizeInBits()) 1010 return Size; 1011 1012 if (auto *DT = dyn_cast<DIDerivedType>(RawType)) { 1013 // Look at the base type. 1014 RawType = DT->getRawBaseType(); 1015 continue; 1016 } 1017 1018 // Missing type or size. 1019 break; 1020 } 1021 1022 // Fail gracefully. 1023 return None; 1024 } 1025 1026 DILabel *DILabel::getImpl(LLVMContext &Context, Metadata *Scope, 1027 MDString *Name, Metadata *File, unsigned Line, 1028 StorageType Storage, 1029 bool ShouldCreate) { 1030 assert(Scope && "Expected scope"); 1031 assert(isCanonical(Name) && "Expected canonical MDString"); 1032 DEFINE_GETIMPL_LOOKUP(DILabel, 1033 (Scope, Name, File, Line)); 1034 Metadata *Ops[] = {Scope, Name, File}; 1035 DEFINE_GETIMPL_STORE(DILabel, (Line), Ops); 1036 } 1037 1038 DIExpression *DIExpression::getImpl(LLVMContext &Context, 1039 ArrayRef<uint64_t> Elements, 1040 StorageType Storage, bool ShouldCreate) { 1041 DEFINE_GETIMPL_LOOKUP(DIExpression, (Elements)); 1042 DEFINE_GETIMPL_STORE_NO_OPS(DIExpression, (Elements)); 1043 } 1044 1045 unsigned DIExpression::ExprOperand::getSize() const { 1046 uint64_t Op = getOp(); 1047 1048 if (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31) 1049 return 2; 1050 1051 switch (Op) { 1052 case dwarf::DW_OP_LLVM_convert: 1053 case dwarf::DW_OP_LLVM_fragment: 1054 case dwarf::DW_OP_bregx: 1055 return 3; 1056 case dwarf::DW_OP_constu: 1057 case dwarf::DW_OP_consts: 1058 case dwarf::DW_OP_deref_size: 1059 case dwarf::DW_OP_plus_uconst: 1060 case dwarf::DW_OP_LLVM_tag_offset: 1061 case dwarf::DW_OP_LLVM_entry_value: 1062 case dwarf::DW_OP_regx: 1063 return 2; 1064 default: 1065 return 1; 1066 } 1067 } 1068 1069 bool DIExpression::isValid() const { 1070 for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) { 1071 // Check that there's space for the operand. 1072 if (I->get() + I->getSize() > E->get()) 1073 return false; 1074 1075 uint64_t Op = I->getOp(); 1076 if ((Op >= dwarf::DW_OP_reg0 && Op <= dwarf::DW_OP_reg31) || 1077 (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31)) 1078 return true; 1079 1080 // Check that the operand is valid. 1081 switch (Op) { 1082 default: 1083 return false; 1084 case dwarf::DW_OP_LLVM_fragment: 1085 // A fragment operator must appear at the end. 1086 return I->get() + I->getSize() == E->get(); 1087 case dwarf::DW_OP_stack_value: { 1088 // Must be the last one or followed by a DW_OP_LLVM_fragment. 1089 if (I->get() + I->getSize() == E->get()) 1090 break; 1091 auto J = I; 1092 if ((++J)->getOp() != dwarf::DW_OP_LLVM_fragment) 1093 return false; 1094 break; 1095 } 1096 case dwarf::DW_OP_swap: { 1097 // Must be more than one implicit element on the stack. 1098 1099 // FIXME: A better way to implement this would be to add a local variable 1100 // that keeps track of the stack depth and introduce something like a 1101 // DW_LLVM_OP_implicit_location as a placeholder for the location this 1102 // DIExpression is attached to, or else pass the number of implicit stack 1103 // elements into isValid. 1104 if (getNumElements() == 1) 1105 return false; 1106 break; 1107 } 1108 case dwarf::DW_OP_LLVM_entry_value: { 1109 // An entry value operator must appear at the beginning and the number of 1110 // operations it cover can currently only be 1, because we support only 1111 // entry values of a simple register location. One reason for this is that 1112 // we currently can't calculate the size of the resulting DWARF block for 1113 // other expressions. 1114 return I->get() == expr_op_begin()->get() && I->getArg(0) == 1 && 1115 getNumElements() == 2; 1116 } 1117 case dwarf::DW_OP_LLVM_implicit_pointer: 1118 case dwarf::DW_OP_LLVM_convert: 1119 case dwarf::DW_OP_LLVM_tag_offset: 1120 case dwarf::DW_OP_constu: 1121 case dwarf::DW_OP_plus_uconst: 1122 case dwarf::DW_OP_plus: 1123 case dwarf::DW_OP_minus: 1124 case dwarf::DW_OP_mul: 1125 case dwarf::DW_OP_div: 1126 case dwarf::DW_OP_mod: 1127 case dwarf::DW_OP_or: 1128 case dwarf::DW_OP_and: 1129 case dwarf::DW_OP_xor: 1130 case dwarf::DW_OP_shl: 1131 case dwarf::DW_OP_shr: 1132 case dwarf::DW_OP_shra: 1133 case dwarf::DW_OP_deref: 1134 case dwarf::DW_OP_deref_size: 1135 case dwarf::DW_OP_xderef: 1136 case dwarf::DW_OP_lit0: 1137 case dwarf::DW_OP_not: 1138 case dwarf::DW_OP_dup: 1139 case dwarf::DW_OP_regx: 1140 case dwarf::DW_OP_bregx: 1141 case dwarf::DW_OP_push_object_address: 1142 case dwarf::DW_OP_over: 1143 case dwarf::DW_OP_consts: 1144 break; 1145 } 1146 } 1147 return true; 1148 } 1149 1150 bool DIExpression::isImplicit() const { 1151 if (!isValid()) 1152 return false; 1153 1154 if (getNumElements() == 0) 1155 return false; 1156 1157 for (const auto &It : expr_ops()) { 1158 switch (It.getOp()) { 1159 default: 1160 break; 1161 case dwarf::DW_OP_stack_value: 1162 case dwarf::DW_OP_LLVM_tag_offset: 1163 return true; 1164 } 1165 } 1166 1167 return false; 1168 } 1169 1170 bool DIExpression::isComplex() const { 1171 if (!isValid()) 1172 return false; 1173 1174 if (getNumElements() == 0) 1175 return false; 1176 1177 // If there are any elements other than fragment or tag_offset, then some 1178 // kind of complex computation occurs. 1179 for (const auto &It : expr_ops()) { 1180 switch (It.getOp()) { 1181 case dwarf::DW_OP_LLVM_tag_offset: 1182 case dwarf::DW_OP_LLVM_fragment: 1183 continue; 1184 default: return true; 1185 } 1186 } 1187 1188 return false; 1189 } 1190 1191 Optional<DIExpression::FragmentInfo> 1192 DIExpression::getFragmentInfo(expr_op_iterator Start, expr_op_iterator End) { 1193 for (auto I = Start; I != End; ++I) 1194 if (I->getOp() == dwarf::DW_OP_LLVM_fragment) { 1195 DIExpression::FragmentInfo Info = {I->getArg(1), I->getArg(0)}; 1196 return Info; 1197 } 1198 return None; 1199 } 1200 1201 void DIExpression::appendOffset(SmallVectorImpl<uint64_t> &Ops, 1202 int64_t Offset) { 1203 if (Offset > 0) { 1204 Ops.push_back(dwarf::DW_OP_plus_uconst); 1205 Ops.push_back(Offset); 1206 } else if (Offset < 0) { 1207 Ops.push_back(dwarf::DW_OP_constu); 1208 Ops.push_back(-Offset); 1209 Ops.push_back(dwarf::DW_OP_minus); 1210 } 1211 } 1212 1213 bool DIExpression::extractIfOffset(int64_t &Offset) const { 1214 if (getNumElements() == 0) { 1215 Offset = 0; 1216 return true; 1217 } 1218 1219 if (getNumElements() == 2 && Elements[0] == dwarf::DW_OP_plus_uconst) { 1220 Offset = Elements[1]; 1221 return true; 1222 } 1223 1224 if (getNumElements() == 3 && Elements[0] == dwarf::DW_OP_constu) { 1225 if (Elements[2] == dwarf::DW_OP_plus) { 1226 Offset = Elements[1]; 1227 return true; 1228 } 1229 if (Elements[2] == dwarf::DW_OP_minus) { 1230 Offset = -Elements[1]; 1231 return true; 1232 } 1233 } 1234 1235 return false; 1236 } 1237 1238 const DIExpression *DIExpression::extractAddressClass(const DIExpression *Expr, 1239 unsigned &AddrClass) { 1240 // FIXME: This seems fragile. Nothing that verifies that these elements 1241 // actually map to ops and not operands. 1242 const unsigned PatternSize = 4; 1243 if (Expr->Elements.size() >= PatternSize && 1244 Expr->Elements[PatternSize - 4] == dwarf::DW_OP_constu && 1245 Expr->Elements[PatternSize - 2] == dwarf::DW_OP_swap && 1246 Expr->Elements[PatternSize - 1] == dwarf::DW_OP_xderef) { 1247 AddrClass = Expr->Elements[PatternSize - 3]; 1248 1249 if (Expr->Elements.size() == PatternSize) 1250 return nullptr; 1251 return DIExpression::get(Expr->getContext(), 1252 makeArrayRef(&*Expr->Elements.begin(), 1253 Expr->Elements.size() - PatternSize)); 1254 } 1255 return Expr; 1256 } 1257 1258 DIExpression *DIExpression::prepend(const DIExpression *Expr, uint8_t Flags, 1259 int64_t Offset) { 1260 SmallVector<uint64_t, 8> Ops; 1261 if (Flags & DIExpression::DerefBefore) 1262 Ops.push_back(dwarf::DW_OP_deref); 1263 1264 appendOffset(Ops, Offset); 1265 if (Flags & DIExpression::DerefAfter) 1266 Ops.push_back(dwarf::DW_OP_deref); 1267 1268 bool StackValue = Flags & DIExpression::StackValue; 1269 bool EntryValue = Flags & DIExpression::EntryValue; 1270 1271 return prependOpcodes(Expr, Ops, StackValue, EntryValue); 1272 } 1273 1274 DIExpression *DIExpression::prependOpcodes(const DIExpression *Expr, 1275 SmallVectorImpl<uint64_t> &Ops, 1276 bool StackValue, 1277 bool EntryValue) { 1278 assert(Expr && "Can't prepend ops to this expression"); 1279 1280 if (EntryValue) { 1281 Ops.push_back(dwarf::DW_OP_LLVM_entry_value); 1282 // Add size info needed for entry value expression. 1283 // Add plus one for target register operand. 1284 Ops.push_back(Expr->getNumElements() + 1); 1285 } 1286 1287 // If there are no ops to prepend, do not even add the DW_OP_stack_value. 1288 if (Ops.empty()) 1289 StackValue = false; 1290 for (auto Op : Expr->expr_ops()) { 1291 // A DW_OP_stack_value comes at the end, but before a DW_OP_LLVM_fragment. 1292 if (StackValue) { 1293 if (Op.getOp() == dwarf::DW_OP_stack_value) 1294 StackValue = false; 1295 else if (Op.getOp() == dwarf::DW_OP_LLVM_fragment) { 1296 Ops.push_back(dwarf::DW_OP_stack_value); 1297 StackValue = false; 1298 } 1299 } 1300 Op.appendToVector(Ops); 1301 } 1302 if (StackValue) 1303 Ops.push_back(dwarf::DW_OP_stack_value); 1304 return DIExpression::get(Expr->getContext(), Ops); 1305 } 1306 1307 DIExpression *DIExpression::append(const DIExpression *Expr, 1308 ArrayRef<uint64_t> Ops) { 1309 assert(Expr && !Ops.empty() && "Can't append ops to this expression"); 1310 1311 // Copy Expr's current op list. 1312 SmallVector<uint64_t, 16> NewOps; 1313 for (auto Op : Expr->expr_ops()) { 1314 // Append new opcodes before DW_OP_{stack_value, LLVM_fragment}. 1315 if (Op.getOp() == dwarf::DW_OP_stack_value || 1316 Op.getOp() == dwarf::DW_OP_LLVM_fragment) { 1317 NewOps.append(Ops.begin(), Ops.end()); 1318 1319 // Ensure that the new opcodes are only appended once. 1320 Ops = None; 1321 } 1322 Op.appendToVector(NewOps); 1323 } 1324 1325 NewOps.append(Ops.begin(), Ops.end()); 1326 auto *result = DIExpression::get(Expr->getContext(), NewOps); 1327 assert(result->isValid() && "concatenated expression is not valid"); 1328 return result; 1329 } 1330 1331 DIExpression *DIExpression::appendToStack(const DIExpression *Expr, 1332 ArrayRef<uint64_t> Ops) { 1333 assert(Expr && !Ops.empty() && "Can't append ops to this expression"); 1334 assert(none_of(Ops, 1335 [](uint64_t Op) { 1336 return Op == dwarf::DW_OP_stack_value || 1337 Op == dwarf::DW_OP_LLVM_fragment; 1338 }) && 1339 "Can't append this op"); 1340 1341 // Append a DW_OP_deref after Expr's current op list if it's non-empty and 1342 // has no DW_OP_stack_value. 1343 // 1344 // Match .* DW_OP_stack_value (DW_OP_LLVM_fragment A B)?. 1345 Optional<FragmentInfo> FI = Expr->getFragmentInfo(); 1346 unsigned DropUntilStackValue = FI.hasValue() ? 3 : 0; 1347 ArrayRef<uint64_t> ExprOpsBeforeFragment = 1348 Expr->getElements().drop_back(DropUntilStackValue); 1349 bool NeedsDeref = (Expr->getNumElements() > DropUntilStackValue) && 1350 (ExprOpsBeforeFragment.back() != dwarf::DW_OP_stack_value); 1351 bool NeedsStackValue = NeedsDeref || ExprOpsBeforeFragment.empty(); 1352 1353 // Append a DW_OP_deref after Expr's current op list if needed, then append 1354 // the new ops, and finally ensure that a single DW_OP_stack_value is present. 1355 SmallVector<uint64_t, 16> NewOps; 1356 if (NeedsDeref) 1357 NewOps.push_back(dwarf::DW_OP_deref); 1358 NewOps.append(Ops.begin(), Ops.end()); 1359 if (NeedsStackValue) 1360 NewOps.push_back(dwarf::DW_OP_stack_value); 1361 return DIExpression::append(Expr, NewOps); 1362 } 1363 1364 Optional<DIExpression *> DIExpression::createFragmentExpression( 1365 const DIExpression *Expr, unsigned OffsetInBits, unsigned SizeInBits) { 1366 SmallVector<uint64_t, 8> Ops; 1367 // Copy over the expression, but leave off any trailing DW_OP_LLVM_fragment. 1368 if (Expr) { 1369 for (auto Op : Expr->expr_ops()) { 1370 switch (Op.getOp()) { 1371 default: break; 1372 case dwarf::DW_OP_shr: 1373 case dwarf::DW_OP_shra: 1374 case dwarf::DW_OP_shl: 1375 case dwarf::DW_OP_plus: 1376 case dwarf::DW_OP_plus_uconst: 1377 case dwarf::DW_OP_minus: 1378 // We can't safely split arithmetic or shift operations into multiple 1379 // fragments because we can't express carry-over between fragments. 1380 // 1381 // FIXME: We *could* preserve the lowest fragment of a constant offset 1382 // operation if the offset fits into SizeInBits. 1383 return None; 1384 case dwarf::DW_OP_LLVM_fragment: { 1385 // Make the new offset point into the existing fragment. 1386 uint64_t FragmentOffsetInBits = Op.getArg(0); 1387 uint64_t FragmentSizeInBits = Op.getArg(1); 1388 (void)FragmentSizeInBits; 1389 assert((OffsetInBits + SizeInBits <= FragmentSizeInBits) && 1390 "new fragment outside of original fragment"); 1391 OffsetInBits += FragmentOffsetInBits; 1392 continue; 1393 } 1394 } 1395 Op.appendToVector(Ops); 1396 } 1397 } 1398 assert(Expr && "Unknown DIExpression"); 1399 Ops.push_back(dwarf::DW_OP_LLVM_fragment); 1400 Ops.push_back(OffsetInBits); 1401 Ops.push_back(SizeInBits); 1402 return DIExpression::get(Expr->getContext(), Ops); 1403 } 1404 1405 bool DIExpression::isConstant() const { 1406 // Recognize DW_OP_constu C DW_OP_stack_value (DW_OP_LLVM_fragment Len Ofs)?. 1407 if (getNumElements() != 3 && getNumElements() != 6) 1408 return false; 1409 if (getElement(0) != dwarf::DW_OP_constu || 1410 getElement(2) != dwarf::DW_OP_stack_value) 1411 return false; 1412 if (getNumElements() == 6 && getElement(3) != dwarf::DW_OP_LLVM_fragment) 1413 return false; 1414 return true; 1415 } 1416 1417 bool DIExpression::isSignedConstant() const { 1418 // Recognize DW_OP_consts C 1419 if (getNumElements() != 2) 1420 return false; 1421 if (getElement(0) != dwarf::DW_OP_consts) 1422 return false; 1423 return true; 1424 } 1425 1426 DIExpression::ExtOps DIExpression::getExtOps(unsigned FromSize, unsigned ToSize, 1427 bool Signed) { 1428 dwarf::TypeKind TK = Signed ? dwarf::DW_ATE_signed : dwarf::DW_ATE_unsigned; 1429 DIExpression::ExtOps Ops{{dwarf::DW_OP_LLVM_convert, FromSize, TK, 1430 dwarf::DW_OP_LLVM_convert, ToSize, TK}}; 1431 return Ops; 1432 } 1433 1434 DIExpression *DIExpression::appendExt(const DIExpression *Expr, 1435 unsigned FromSize, unsigned ToSize, 1436 bool Signed) { 1437 return appendToStack(Expr, getExtOps(FromSize, ToSize, Signed)); 1438 } 1439 1440 DIGlobalVariableExpression * 1441 DIGlobalVariableExpression::getImpl(LLVMContext &Context, Metadata *Variable, 1442 Metadata *Expression, StorageType Storage, 1443 bool ShouldCreate) { 1444 DEFINE_GETIMPL_LOOKUP(DIGlobalVariableExpression, (Variable, Expression)); 1445 Metadata *Ops[] = {Variable, Expression}; 1446 DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIGlobalVariableExpression, Ops); 1447 } 1448 1449 DIObjCProperty *DIObjCProperty::getImpl( 1450 LLVMContext &Context, MDString *Name, Metadata *File, unsigned Line, 1451 MDString *GetterName, MDString *SetterName, unsigned Attributes, 1452 Metadata *Type, StorageType Storage, bool ShouldCreate) { 1453 assert(isCanonical(Name) && "Expected canonical MDString"); 1454 assert(isCanonical(GetterName) && "Expected canonical MDString"); 1455 assert(isCanonical(SetterName) && "Expected canonical MDString"); 1456 DEFINE_GETIMPL_LOOKUP(DIObjCProperty, (Name, File, Line, GetterName, 1457 SetterName, Attributes, Type)); 1458 Metadata *Ops[] = {Name, File, GetterName, SetterName, Type}; 1459 DEFINE_GETIMPL_STORE(DIObjCProperty, (Line, Attributes), Ops); 1460 } 1461 1462 DIImportedEntity *DIImportedEntity::getImpl(LLVMContext &Context, unsigned Tag, 1463 Metadata *Scope, Metadata *Entity, 1464 Metadata *File, unsigned Line, 1465 MDString *Name, StorageType Storage, 1466 bool ShouldCreate) { 1467 assert(isCanonical(Name) && "Expected canonical MDString"); 1468 DEFINE_GETIMPL_LOOKUP(DIImportedEntity, 1469 (Tag, Scope, Entity, File, Line, Name)); 1470 Metadata *Ops[] = {Scope, Entity, Name, File}; 1471 DEFINE_GETIMPL_STORE(DIImportedEntity, (Tag, Line), Ops); 1472 } 1473 1474 DIMacro *DIMacro::getImpl(LLVMContext &Context, unsigned MIType, 1475 unsigned Line, MDString *Name, MDString *Value, 1476 StorageType Storage, bool ShouldCreate) { 1477 assert(isCanonical(Name) && "Expected canonical MDString"); 1478 DEFINE_GETIMPL_LOOKUP(DIMacro, (MIType, Line, Name, Value)); 1479 Metadata *Ops[] = { Name, Value }; 1480 DEFINE_GETIMPL_STORE(DIMacro, (MIType, Line), Ops); 1481 } 1482 1483 DIMacroFile *DIMacroFile::getImpl(LLVMContext &Context, unsigned MIType, 1484 unsigned Line, Metadata *File, 1485 Metadata *Elements, StorageType Storage, 1486 bool ShouldCreate) { 1487 DEFINE_GETIMPL_LOOKUP(DIMacroFile, 1488 (MIType, Line, File, Elements)); 1489 Metadata *Ops[] = { File, Elements }; 1490 DEFINE_GETIMPL_STORE(DIMacroFile, (MIType, Line), Ops); 1491 } 1492