1 //===- DebugInfoMetadata.cpp - Implement debug info metadata --------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the debug info Metadata classes. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/IR/DebugInfoMetadata.h" 15 #include "LLVMContextImpl.h" 16 #include "MetadataImpl.h" 17 #include "llvm/ADT/StringSwitch.h" 18 #include "llvm/IR/DIBuilder.h" 19 #include "llvm/IR/Function.h" 20 21 using namespace llvm; 22 23 DILocation::DILocation(LLVMContext &C, StorageType Storage, unsigned Line, 24 unsigned Column, ArrayRef<Metadata *> MDs) 25 : MDNode(C, DILocationKind, Storage, MDs) { 26 assert((MDs.size() == 1 || MDs.size() == 2) && 27 "Expected a scope and optional inlined-at"); 28 29 // Set line and column. 30 assert(Column < (1u << 16) && "Expected 16-bit column"); 31 32 SubclassData32 = Line; 33 SubclassData16 = Column; 34 } 35 36 static void adjustColumn(unsigned &Column) { 37 // Set to unknown on overflow. We only have 16 bits to play with here. 38 if (Column >= (1u << 16)) 39 Column = 0; 40 } 41 42 DILocation *DILocation::getImpl(LLVMContext &Context, unsigned Line, 43 unsigned Column, Metadata *Scope, 44 Metadata *InlinedAt, StorageType Storage, 45 bool ShouldCreate) { 46 // Fixup column. 47 adjustColumn(Column); 48 49 if (Storage == Uniqued) { 50 if (auto *N = 51 getUniqued(Context.pImpl->DILocations, 52 DILocationInfo::KeyTy(Line, Column, Scope, InlinedAt))) 53 return N; 54 if (!ShouldCreate) 55 return nullptr; 56 } else { 57 assert(ShouldCreate && "Expected non-uniqued nodes to always be created"); 58 } 59 60 SmallVector<Metadata *, 2> Ops; 61 Ops.push_back(Scope); 62 if (InlinedAt) 63 Ops.push_back(InlinedAt); 64 return storeImpl(new (Ops.size()) 65 DILocation(Context, Storage, Line, Column, Ops), 66 Storage, Context.pImpl->DILocations); 67 } 68 69 DINode::DIFlags DINode::getFlag(StringRef Flag) { 70 return StringSwitch<DIFlags>(Flag) 71 #define HANDLE_DI_FLAG(ID, NAME) .Case("DIFlag" #NAME, Flag##NAME) 72 #include "llvm/IR/DebugInfoFlags.def" 73 .Default(DINode::FlagZero); 74 } 75 76 StringRef DINode::getFlagString(DIFlags Flag) { 77 switch (Flag) { 78 #define HANDLE_DI_FLAG(ID, NAME) \ 79 case Flag##NAME: \ 80 return "DIFlag" #NAME; 81 #include "llvm/IR/DebugInfoFlags.def" 82 } 83 return ""; 84 } 85 86 DINode::DIFlags DINode::splitFlags(DIFlags Flags, 87 SmallVectorImpl<DIFlags> &SplitFlags) { 88 // Flags that are packed together need to be specially handled, so 89 // that, for example, we emit "DIFlagPublic" and not 90 // "DIFlagPrivate | DIFlagProtected". 91 if (DIFlags A = Flags & FlagAccessibility) { 92 if (A == FlagPrivate) 93 SplitFlags.push_back(FlagPrivate); 94 else if (A == FlagProtected) 95 SplitFlags.push_back(FlagProtected); 96 else 97 SplitFlags.push_back(FlagPublic); 98 Flags &= ~A; 99 } 100 if (DIFlags R = Flags & FlagPtrToMemberRep) { 101 if (R == FlagSingleInheritance) 102 SplitFlags.push_back(FlagSingleInheritance); 103 else if (R == FlagMultipleInheritance) 104 SplitFlags.push_back(FlagMultipleInheritance); 105 else 106 SplitFlags.push_back(FlagVirtualInheritance); 107 Flags &= ~R; 108 } 109 if ((Flags & FlagIndirectVirtualBase) == FlagIndirectVirtualBase) { 110 Flags &= ~FlagIndirectVirtualBase; 111 SplitFlags.push_back(FlagIndirectVirtualBase); 112 } 113 114 #define HANDLE_DI_FLAG(ID, NAME) \ 115 if (DIFlags Bit = Flags & Flag##NAME) { \ 116 SplitFlags.push_back(Bit); \ 117 Flags &= ~Bit; \ 118 } 119 #include "llvm/IR/DebugInfoFlags.def" 120 return Flags; 121 } 122 123 DIScopeRef DIScope::getScope() const { 124 if (auto *T = dyn_cast<DIType>(this)) 125 return T->getScope(); 126 127 if (auto *SP = dyn_cast<DISubprogram>(this)) 128 return SP->getScope(); 129 130 if (auto *LB = dyn_cast<DILexicalBlockBase>(this)) 131 return LB->getScope(); 132 133 if (auto *NS = dyn_cast<DINamespace>(this)) 134 return NS->getScope(); 135 136 if (auto *M = dyn_cast<DIModule>(this)) 137 return M->getScope(); 138 139 assert((isa<DIFile>(this) || isa<DICompileUnit>(this)) && 140 "Unhandled type of scope."); 141 return nullptr; 142 } 143 144 StringRef DIScope::getName() const { 145 if (auto *T = dyn_cast<DIType>(this)) 146 return T->getName(); 147 if (auto *SP = dyn_cast<DISubprogram>(this)) 148 return SP->getName(); 149 if (auto *NS = dyn_cast<DINamespace>(this)) 150 return NS->getName(); 151 if (auto *M = dyn_cast<DIModule>(this)) 152 return M->getName(); 153 assert((isa<DILexicalBlockBase>(this) || isa<DIFile>(this) || 154 isa<DICompileUnit>(this)) && 155 "Unhandled type of scope."); 156 return ""; 157 } 158 159 #ifndef NDEBUG 160 static bool isCanonical(const MDString *S) { 161 return !S || !S->getString().empty(); 162 } 163 #endif 164 165 GenericDINode *GenericDINode::getImpl(LLVMContext &Context, unsigned Tag, 166 MDString *Header, 167 ArrayRef<Metadata *> DwarfOps, 168 StorageType Storage, bool ShouldCreate) { 169 unsigned Hash = 0; 170 if (Storage == Uniqued) { 171 GenericDINodeInfo::KeyTy Key(Tag, Header, DwarfOps); 172 if (auto *N = getUniqued(Context.pImpl->GenericDINodes, Key)) 173 return N; 174 if (!ShouldCreate) 175 return nullptr; 176 Hash = Key.getHash(); 177 } else { 178 assert(ShouldCreate && "Expected non-uniqued nodes to always be created"); 179 } 180 181 // Use a nullptr for empty headers. 182 assert(isCanonical(Header) && "Expected canonical MDString"); 183 Metadata *PreOps[] = {Header}; 184 return storeImpl(new (DwarfOps.size() + 1) GenericDINode( 185 Context, Storage, Hash, Tag, PreOps, DwarfOps), 186 Storage, Context.pImpl->GenericDINodes); 187 } 188 189 void GenericDINode::recalculateHash() { 190 setHash(GenericDINodeInfo::KeyTy::calculateHash(this)); 191 } 192 193 #define UNWRAP_ARGS_IMPL(...) __VA_ARGS__ 194 #define UNWRAP_ARGS(ARGS) UNWRAP_ARGS_IMPL ARGS 195 #define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS) \ 196 do { \ 197 if (Storage == Uniqued) { \ 198 if (auto *N = getUniqued(Context.pImpl->CLASS##s, \ 199 CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS)))) \ 200 return N; \ 201 if (!ShouldCreate) \ 202 return nullptr; \ 203 } else { \ 204 assert(ShouldCreate && \ 205 "Expected non-uniqued nodes to always be created"); \ 206 } \ 207 } while (false) 208 #define DEFINE_GETIMPL_STORE(CLASS, ARGS, OPS) \ 209 return storeImpl(new (array_lengthof(OPS)) \ 210 CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \ 211 Storage, Context.pImpl->CLASS##s) 212 #define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS) \ 213 return storeImpl(new (0u) CLASS(Context, Storage, UNWRAP_ARGS(ARGS)), \ 214 Storage, Context.pImpl->CLASS##s) 215 #define DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(CLASS, OPS) \ 216 return storeImpl(new (array_lengthof(OPS)) CLASS(Context, Storage, OPS), \ 217 Storage, Context.pImpl->CLASS##s) 218 #define DEFINE_GETIMPL_STORE_N(CLASS, ARGS, OPS, NUM_OPS) \ 219 return storeImpl(new (NUM_OPS) \ 220 CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \ 221 Storage, Context.pImpl->CLASS##s) 222 223 DISubrange *DISubrange::getImpl(LLVMContext &Context, int64_t Count, int64_t Lo, 224 StorageType Storage, bool ShouldCreate) { 225 DEFINE_GETIMPL_LOOKUP(DISubrange, (Count, Lo)); 226 DEFINE_GETIMPL_STORE_NO_OPS(DISubrange, (Count, Lo)); 227 } 228 229 DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, int64_t Value, 230 MDString *Name, StorageType Storage, 231 bool ShouldCreate) { 232 assert(isCanonical(Name) && "Expected canonical MDString"); 233 DEFINE_GETIMPL_LOOKUP(DIEnumerator, (Value, Name)); 234 Metadata *Ops[] = {Name}; 235 DEFINE_GETIMPL_STORE(DIEnumerator, (Value), Ops); 236 } 237 238 DIBasicType *DIBasicType::getImpl(LLVMContext &Context, unsigned Tag, 239 MDString *Name, uint64_t SizeInBits, 240 uint32_t AlignInBits, unsigned Encoding, 241 StorageType Storage, bool ShouldCreate) { 242 assert(isCanonical(Name) && "Expected canonical MDString"); 243 DEFINE_GETIMPL_LOOKUP(DIBasicType, 244 (Tag, Name, SizeInBits, AlignInBits, Encoding)); 245 Metadata *Ops[] = {nullptr, nullptr, Name}; 246 DEFINE_GETIMPL_STORE(DIBasicType, (Tag, SizeInBits, AlignInBits, Encoding), 247 Ops); 248 } 249 250 DIDerivedType *DIDerivedType::getImpl( 251 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File, 252 unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, 253 uint32_t AlignInBits, uint64_t OffsetInBits, 254 Optional<unsigned> DWARFAddressSpace, DIFlags Flags, Metadata *ExtraData, 255 StorageType Storage, bool ShouldCreate) { 256 assert(isCanonical(Name) && "Expected canonical MDString"); 257 DEFINE_GETIMPL_LOOKUP(DIDerivedType, 258 (Tag, Name, File, Line, Scope, BaseType, SizeInBits, 259 AlignInBits, OffsetInBits, DWARFAddressSpace, Flags, 260 ExtraData)); 261 Metadata *Ops[] = {File, Scope, Name, BaseType, ExtraData}; 262 DEFINE_GETIMPL_STORE( 263 DIDerivedType, (Tag, Line, SizeInBits, AlignInBits, OffsetInBits, 264 DWARFAddressSpace, Flags), Ops); 265 } 266 267 DICompositeType *DICompositeType::getImpl( 268 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File, 269 unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, 270 uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags, 271 Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder, 272 Metadata *TemplateParams, MDString *Identifier, StorageType Storage, 273 bool ShouldCreate) { 274 assert(isCanonical(Name) && "Expected canonical MDString"); 275 276 // Keep this in sync with buildODRType. 277 DEFINE_GETIMPL_LOOKUP( 278 DICompositeType, (Tag, Name, File, Line, Scope, BaseType, SizeInBits, 279 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, 280 VTableHolder, TemplateParams, Identifier)); 281 Metadata *Ops[] = {File, Scope, Name, BaseType, 282 Elements, VTableHolder, TemplateParams, Identifier}; 283 DEFINE_GETIMPL_STORE(DICompositeType, (Tag, Line, RuntimeLang, SizeInBits, 284 AlignInBits, OffsetInBits, Flags), 285 Ops); 286 } 287 288 DICompositeType *DICompositeType::buildODRType( 289 LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name, 290 Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, 291 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, 292 DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, 293 Metadata *VTableHolder, Metadata *TemplateParams) { 294 assert(!Identifier.getString().empty() && "Expected valid identifier"); 295 if (!Context.isODRUniquingDebugTypes()) 296 return nullptr; 297 auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier]; 298 if (!CT) 299 return CT = DICompositeType::getDistinct( 300 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, 301 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, 302 VTableHolder, TemplateParams, &Identifier); 303 304 // Only mutate CT if it's a forward declaration and the new operands aren't. 305 assert(CT->getRawIdentifier() == &Identifier && "Wrong ODR identifier?"); 306 if (!CT->isForwardDecl() || (Flags & DINode::FlagFwdDecl)) 307 return CT; 308 309 // Mutate CT in place. Keep this in sync with getImpl. 310 CT->mutate(Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits, 311 Flags); 312 Metadata *Ops[] = {File, Scope, Name, BaseType, 313 Elements, VTableHolder, TemplateParams, &Identifier}; 314 assert((std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() && 315 "Mismatched number of operands"); 316 for (unsigned I = 0, E = CT->getNumOperands(); I != E; ++I) 317 if (Ops[I] != CT->getOperand(I)) 318 CT->setOperand(I, Ops[I]); 319 return CT; 320 } 321 322 DICompositeType *DICompositeType::getODRType( 323 LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name, 324 Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, 325 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, 326 DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, 327 Metadata *VTableHolder, Metadata *TemplateParams) { 328 assert(!Identifier.getString().empty() && "Expected valid identifier"); 329 if (!Context.isODRUniquingDebugTypes()) 330 return nullptr; 331 auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier]; 332 if (!CT) 333 CT = DICompositeType::getDistinct( 334 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, 335 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder, 336 TemplateParams, &Identifier); 337 return CT; 338 } 339 340 DICompositeType *DICompositeType::getODRTypeIfExists(LLVMContext &Context, 341 MDString &Identifier) { 342 assert(!Identifier.getString().empty() && "Expected valid identifier"); 343 if (!Context.isODRUniquingDebugTypes()) 344 return nullptr; 345 return Context.pImpl->DITypeMap->lookup(&Identifier); 346 } 347 348 DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context, DIFlags Flags, 349 uint8_t CC, Metadata *TypeArray, 350 StorageType Storage, 351 bool ShouldCreate) { 352 DEFINE_GETIMPL_LOOKUP(DISubroutineType, (Flags, CC, TypeArray)); 353 Metadata *Ops[] = {nullptr, nullptr, nullptr, TypeArray}; 354 DEFINE_GETIMPL_STORE(DISubroutineType, (Flags, CC), Ops); 355 } 356 357 // FIXME: Implement this string-enum correspondence with a .def file and macros, 358 // so that the association is explicit rather than implied. 359 static const char *ChecksumKindName[DIFile::CSK_Last + 1] = { 360 "CSK_None", 361 "CSK_MD5", 362 "CSK_SHA1" 363 }; 364 365 DIFile::ChecksumKind DIFile::getChecksumKind(StringRef CSKindStr) { 366 return StringSwitch<DIFile::ChecksumKind>(CSKindStr) 367 .Case("CSK_MD5", DIFile::CSK_MD5) 368 .Case("CSK_SHA1", DIFile::CSK_SHA1) 369 .Default(DIFile::CSK_None); 370 } 371 372 StringRef DIFile::getChecksumKindAsString() const { 373 assert(CSKind <= DIFile::CSK_Last && "Invalid checksum kind"); 374 return ChecksumKindName[CSKind]; 375 } 376 377 DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename, 378 MDString *Directory, DIFile::ChecksumKind CSKind, 379 MDString *Checksum, StorageType Storage, 380 bool ShouldCreate) { 381 assert(isCanonical(Filename) && "Expected canonical MDString"); 382 assert(isCanonical(Directory) && "Expected canonical MDString"); 383 assert(isCanonical(Checksum) && "Expected canonical MDString"); 384 DEFINE_GETIMPL_LOOKUP(DIFile, (Filename, Directory, CSKind, Checksum)); 385 Metadata *Ops[] = {Filename, Directory, Checksum}; 386 DEFINE_GETIMPL_STORE(DIFile, (CSKind), Ops); 387 } 388 389 DICompileUnit *DICompileUnit::getImpl( 390 LLVMContext &Context, unsigned SourceLanguage, Metadata *File, 391 MDString *Producer, bool IsOptimized, MDString *Flags, 392 unsigned RuntimeVersion, MDString *SplitDebugFilename, 393 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes, 394 Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros, 395 uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling, 396 bool GnuPubnames, StorageType Storage, bool ShouldCreate) { 397 assert(Storage != Uniqued && "Cannot unique DICompileUnit"); 398 assert(isCanonical(Producer) && "Expected canonical MDString"); 399 assert(isCanonical(Flags) && "Expected canonical MDString"); 400 assert(isCanonical(SplitDebugFilename) && "Expected canonical MDString"); 401 402 Metadata *Ops[] = { 403 File, Producer, Flags, SplitDebugFilename, 404 EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities, 405 Macros}; 406 return storeImpl(new (array_lengthof(Ops)) DICompileUnit( 407 Context, Storage, SourceLanguage, IsOptimized, 408 RuntimeVersion, EmissionKind, DWOId, SplitDebugInlining, 409 DebugInfoForProfiling, GnuPubnames, Ops), 410 Storage); 411 } 412 413 Optional<DICompileUnit::DebugEmissionKind> 414 DICompileUnit::getEmissionKind(StringRef Str) { 415 return StringSwitch<Optional<DebugEmissionKind>>(Str) 416 .Case("NoDebug", NoDebug) 417 .Case("FullDebug", FullDebug) 418 .Case("LineTablesOnly", LineTablesOnly) 419 .Default(None); 420 } 421 422 const char *DICompileUnit::EmissionKindString(DebugEmissionKind EK) { 423 switch (EK) { 424 case NoDebug: return "NoDebug"; 425 case FullDebug: return "FullDebug"; 426 case LineTablesOnly: return "LineTablesOnly"; 427 } 428 return nullptr; 429 } 430 431 DISubprogram *DILocalScope::getSubprogram() const { 432 if (auto *Block = dyn_cast<DILexicalBlockBase>(this)) 433 return Block->getScope()->getSubprogram(); 434 return const_cast<DISubprogram *>(cast<DISubprogram>(this)); 435 } 436 437 DILocalScope *DILocalScope::getNonLexicalBlockFileScope() const { 438 if (auto *File = dyn_cast<DILexicalBlockFile>(this)) 439 return File->getScope()->getNonLexicalBlockFileScope(); 440 return const_cast<DILocalScope *>(this); 441 } 442 443 DISubprogram *DISubprogram::getImpl( 444 LLVMContext &Context, Metadata *Scope, MDString *Name, 445 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type, 446 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine, 447 Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex, 448 int ThisAdjustment, DIFlags Flags, bool IsOptimized, Metadata *Unit, 449 Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables, 450 Metadata *ThrownTypes, StorageType Storage, bool ShouldCreate) { 451 assert(isCanonical(Name) && "Expected canonical MDString"); 452 assert(isCanonical(LinkageName) && "Expected canonical MDString"); 453 DEFINE_GETIMPL_LOOKUP( 454 DISubprogram, (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, 455 IsDefinition, ScopeLine, ContainingType, Virtuality, 456 VirtualIndex, ThisAdjustment, Flags, IsOptimized, Unit, 457 TemplateParams, Declaration, Variables, ThrownTypes)); 458 SmallVector<Metadata *, 11> Ops = { 459 File, Scope, Name, LinkageName, Type, Unit, 460 Declaration, Variables, ContainingType, TemplateParams, ThrownTypes}; 461 if (!ThrownTypes) { 462 Ops.pop_back(); 463 if (!TemplateParams) { 464 Ops.pop_back(); 465 if (!ContainingType) 466 Ops.pop_back(); 467 } 468 } 469 DEFINE_GETIMPL_STORE_N(DISubprogram, 470 (Line, ScopeLine, Virtuality, VirtualIndex, 471 ThisAdjustment, Flags, IsLocalToUnit, IsDefinition, 472 IsOptimized), 473 Ops, Ops.size()); 474 } 475 476 bool DISubprogram::describes(const Function *F) const { 477 assert(F && "Invalid function"); 478 if (F->getSubprogram() == this) 479 return true; 480 StringRef Name = getLinkageName(); 481 if (Name.empty()) 482 Name = getName(); 483 return F->getName() == Name; 484 } 485 486 DILexicalBlock *DILexicalBlock::getImpl(LLVMContext &Context, Metadata *Scope, 487 Metadata *File, unsigned Line, 488 unsigned Column, StorageType Storage, 489 bool ShouldCreate) { 490 // Fixup column. 491 adjustColumn(Column); 492 493 assert(Scope && "Expected scope"); 494 DEFINE_GETIMPL_LOOKUP(DILexicalBlock, (Scope, File, Line, Column)); 495 Metadata *Ops[] = {File, Scope}; 496 DEFINE_GETIMPL_STORE(DILexicalBlock, (Line, Column), Ops); 497 } 498 499 DILexicalBlockFile *DILexicalBlockFile::getImpl(LLVMContext &Context, 500 Metadata *Scope, Metadata *File, 501 unsigned Discriminator, 502 StorageType Storage, 503 bool ShouldCreate) { 504 assert(Scope && "Expected scope"); 505 DEFINE_GETIMPL_LOOKUP(DILexicalBlockFile, (Scope, File, Discriminator)); 506 Metadata *Ops[] = {File, Scope}; 507 DEFINE_GETIMPL_STORE(DILexicalBlockFile, (Discriminator), Ops); 508 } 509 510 DINamespace *DINamespace::getImpl(LLVMContext &Context, Metadata *Scope, 511 MDString *Name, bool ExportSymbols, 512 StorageType Storage, bool ShouldCreate) { 513 assert(isCanonical(Name) && "Expected canonical MDString"); 514 DEFINE_GETIMPL_LOOKUP(DINamespace, (Scope, Name, ExportSymbols)); 515 // The nullptr is for DIScope's File operand. This should be refactored. 516 Metadata *Ops[] = {nullptr, Scope, Name}; 517 DEFINE_GETIMPL_STORE(DINamespace, (ExportSymbols), Ops); 518 } 519 520 DIModule *DIModule::getImpl(LLVMContext &Context, Metadata *Scope, 521 MDString *Name, MDString *ConfigurationMacros, 522 MDString *IncludePath, MDString *ISysRoot, 523 StorageType Storage, bool ShouldCreate) { 524 assert(isCanonical(Name) && "Expected canonical MDString"); 525 DEFINE_GETIMPL_LOOKUP( 526 DIModule, (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot)); 527 Metadata *Ops[] = {Scope, Name, ConfigurationMacros, IncludePath, ISysRoot}; 528 DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIModule, Ops); 529 } 530 531 DITemplateTypeParameter *DITemplateTypeParameter::getImpl(LLVMContext &Context, 532 MDString *Name, 533 Metadata *Type, 534 StorageType Storage, 535 bool ShouldCreate) { 536 assert(isCanonical(Name) && "Expected canonical MDString"); 537 DEFINE_GETIMPL_LOOKUP(DITemplateTypeParameter, (Name, Type)); 538 Metadata *Ops[] = {Name, Type}; 539 DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DITemplateTypeParameter, Ops); 540 } 541 542 DITemplateValueParameter *DITemplateValueParameter::getImpl( 543 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *Type, 544 Metadata *Value, StorageType Storage, bool ShouldCreate) { 545 assert(isCanonical(Name) && "Expected canonical MDString"); 546 DEFINE_GETIMPL_LOOKUP(DITemplateValueParameter, (Tag, Name, Type, Value)); 547 Metadata *Ops[] = {Name, Type, Value}; 548 DEFINE_GETIMPL_STORE(DITemplateValueParameter, (Tag), Ops); 549 } 550 551 DIGlobalVariable * 552 DIGlobalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name, 553 MDString *LinkageName, Metadata *File, unsigned Line, 554 Metadata *Type, bool IsLocalToUnit, bool IsDefinition, 555 Metadata *StaticDataMemberDeclaration, 556 uint32_t AlignInBits, StorageType Storage, 557 bool ShouldCreate) { 558 assert(isCanonical(Name) && "Expected canonical MDString"); 559 assert(isCanonical(LinkageName) && "Expected canonical MDString"); 560 DEFINE_GETIMPL_LOOKUP(DIGlobalVariable, 561 (Scope, Name, LinkageName, File, Line, Type, 562 IsLocalToUnit, IsDefinition, 563 StaticDataMemberDeclaration, AlignInBits)); 564 Metadata *Ops[] = { 565 Scope, Name, File, Type, Name, LinkageName, StaticDataMemberDeclaration}; 566 DEFINE_GETIMPL_STORE(DIGlobalVariable, 567 (Line, IsLocalToUnit, IsDefinition, AlignInBits), 568 Ops); 569 } 570 571 DILocalVariable *DILocalVariable::getImpl(LLVMContext &Context, Metadata *Scope, 572 MDString *Name, Metadata *File, 573 unsigned Line, Metadata *Type, 574 unsigned Arg, DIFlags Flags, 575 uint32_t AlignInBits, 576 StorageType Storage, 577 bool ShouldCreate) { 578 // 64K ought to be enough for any frontend. 579 assert(Arg <= UINT16_MAX && "Expected argument number to fit in 16-bits"); 580 581 assert(Scope && "Expected scope"); 582 assert(isCanonical(Name) && "Expected canonical MDString"); 583 DEFINE_GETIMPL_LOOKUP(DILocalVariable, 584 (Scope, Name, File, Line, Type, Arg, Flags, 585 AlignInBits)); 586 Metadata *Ops[] = {Scope, Name, File, Type}; 587 DEFINE_GETIMPL_STORE(DILocalVariable, (Line, Arg, Flags, AlignInBits), Ops); 588 } 589 590 DIExpression *DIExpression::getImpl(LLVMContext &Context, 591 ArrayRef<uint64_t> Elements, 592 StorageType Storage, bool ShouldCreate) { 593 DEFINE_GETIMPL_LOOKUP(DIExpression, (Elements)); 594 DEFINE_GETIMPL_STORE_NO_OPS(DIExpression, (Elements)); 595 } 596 597 unsigned DIExpression::ExprOperand::getSize() const { 598 switch (getOp()) { 599 case dwarf::DW_OP_LLVM_fragment: 600 return 3; 601 case dwarf::DW_OP_constu: 602 case dwarf::DW_OP_plus_uconst: 603 return 2; 604 default: 605 return 1; 606 } 607 } 608 609 bool DIExpression::isValid() const { 610 for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) { 611 // Check that there's space for the operand. 612 if (I->get() + I->getSize() > E->get()) 613 return false; 614 615 // Check that the operand is valid. 616 switch (I->getOp()) { 617 default: 618 return false; 619 case dwarf::DW_OP_LLVM_fragment: 620 // A fragment operator must appear at the end. 621 return I->get() + I->getSize() == E->get(); 622 case dwarf::DW_OP_stack_value: { 623 // Must be the last one or followed by a DW_OP_LLVM_fragment. 624 if (I->get() + I->getSize() == E->get()) 625 break; 626 auto J = I; 627 if ((++J)->getOp() != dwarf::DW_OP_LLVM_fragment) 628 return false; 629 break; 630 } 631 case dwarf::DW_OP_swap: { 632 // Must be more than one implicit element on the stack. 633 634 // FIXME: A better way to implement this would be to add a local variable 635 // that keeps track of the stack depth and introduce something like a 636 // DW_LLVM_OP_implicit_location as a placeholder for the location this 637 // DIExpression is attached to, or else pass the number of implicit stack 638 // elements into isValid. 639 if (getNumElements() == 1) 640 return false; 641 break; 642 } 643 case dwarf::DW_OP_constu: 644 case dwarf::DW_OP_plus_uconst: 645 case dwarf::DW_OP_plus: 646 case dwarf::DW_OP_minus: 647 case dwarf::DW_OP_mul: 648 case dwarf::DW_OP_deref: 649 case dwarf::DW_OP_xderef: 650 break; 651 } 652 } 653 return true; 654 } 655 656 Optional<DIExpression::FragmentInfo> 657 DIExpression::getFragmentInfo(expr_op_iterator Start, expr_op_iterator End) { 658 for (auto I = Start; I != End; ++I) 659 if (I->getOp() == dwarf::DW_OP_LLVM_fragment) { 660 DIExpression::FragmentInfo Info = {I->getArg(1), I->getArg(0)}; 661 return Info; 662 } 663 return None; 664 } 665 666 void DIExpression::appendOffset(SmallVectorImpl<uint64_t> &Ops, 667 int64_t Offset) { 668 if (Offset > 0) { 669 Ops.push_back(dwarf::DW_OP_plus_uconst); 670 Ops.push_back(Offset); 671 } else if (Offset < 0) { 672 Ops.push_back(dwarf::DW_OP_constu); 673 Ops.push_back(-Offset); 674 Ops.push_back(dwarf::DW_OP_minus); 675 } 676 } 677 678 bool DIExpression::extractIfOffset(int64_t &Offset) const { 679 if (getNumElements() == 0) { 680 Offset = 0; 681 return true; 682 } 683 684 if (getNumElements() == 2 && Elements[0] == dwarf::DW_OP_plus_uconst) { 685 Offset = Elements[1]; 686 return true; 687 } 688 689 if (getNumElements() == 3 && Elements[0] == dwarf::DW_OP_constu) { 690 if (Elements[2] == dwarf::DW_OP_plus) { 691 Offset = Elements[1]; 692 return true; 693 } 694 if (Elements[2] == dwarf::DW_OP_minus) { 695 Offset = -Elements[1]; 696 return true; 697 } 698 } 699 700 return false; 701 } 702 703 DIExpression *DIExpression::prepend(const DIExpression *Expr, bool Deref, 704 int64_t Offset, bool StackValue) { 705 SmallVector<uint64_t, 8> Ops; 706 appendOffset(Ops, Offset); 707 if (Deref) 708 Ops.push_back(dwarf::DW_OP_deref); 709 if (Expr) 710 for (auto Op : Expr->expr_ops()) { 711 // A DW_OP_stack_value comes at the end, but before a DW_OP_LLVM_fragment. 712 if (StackValue) { 713 if (Op.getOp() == dwarf::DW_OP_stack_value) 714 StackValue = false; 715 else if (Op.getOp() == dwarf::DW_OP_LLVM_fragment) { 716 Ops.push_back(dwarf::DW_OP_stack_value); 717 StackValue = false; 718 } 719 } 720 Ops.push_back(Op.getOp()); 721 for (unsigned I = 0; I < Op.getNumArgs(); ++I) 722 Ops.push_back(Op.getArg(I)); 723 } 724 if (StackValue) 725 Ops.push_back(dwarf::DW_OP_stack_value); 726 return DIExpression::get(Expr->getContext(), Ops); 727 } 728 729 DIExpression *DIExpression::createFragmentExpression(const DIExpression *Expr, 730 unsigned OffsetInBits, 731 unsigned SizeInBits) { 732 SmallVector<uint64_t, 8> Ops; 733 // Copy over the expression, but leave off any trailing DW_OP_LLVM_fragment. 734 if (Expr) { 735 for (auto Op : Expr->expr_ops()) { 736 if (Op.getOp() == dwarf::DW_OP_LLVM_fragment) { 737 // Make the new offset point into the existing fragment. 738 uint64_t FragmentOffsetInBits = Op.getArg(0); 739 // Op.getArg(0) is FragmentOffsetInBits. 740 // Op.getArg(1) is FragmentSizeInBits. 741 assert((OffsetInBits + SizeInBits <= Op.getArg(0) + Op.getArg(1)) && 742 "new fragment outside of original fragment"); 743 OffsetInBits += FragmentOffsetInBits; 744 break; 745 } 746 Ops.push_back(Op.getOp()); 747 for (unsigned I = 0; I < Op.getNumArgs(); ++I) 748 Ops.push_back(Op.getArg(I)); 749 } 750 } 751 Ops.push_back(dwarf::DW_OP_LLVM_fragment); 752 Ops.push_back(OffsetInBits); 753 Ops.push_back(SizeInBits); 754 return DIExpression::get(Expr->getContext(), Ops); 755 } 756 757 bool DIExpression::isConstant() const { 758 // Recognize DW_OP_constu C DW_OP_stack_value (DW_OP_LLVM_fragment Len Ofs)?. 759 if (getNumElements() != 3 && getNumElements() != 6) 760 return false; 761 if (getElement(0) != dwarf::DW_OP_constu || 762 getElement(2) != dwarf::DW_OP_stack_value) 763 return false; 764 if (getNumElements() == 6 && getElement(3) != dwarf::DW_OP_LLVM_fragment) 765 return false; 766 return true; 767 } 768 769 DIGlobalVariableExpression * 770 DIGlobalVariableExpression::getImpl(LLVMContext &Context, Metadata *Variable, 771 Metadata *Expression, StorageType Storage, 772 bool ShouldCreate) { 773 DEFINE_GETIMPL_LOOKUP(DIGlobalVariableExpression, (Variable, Expression)); 774 Metadata *Ops[] = {Variable, Expression}; 775 DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIGlobalVariableExpression, Ops); 776 } 777 778 DIObjCProperty *DIObjCProperty::getImpl( 779 LLVMContext &Context, MDString *Name, Metadata *File, unsigned Line, 780 MDString *GetterName, MDString *SetterName, unsigned Attributes, 781 Metadata *Type, StorageType Storage, bool ShouldCreate) { 782 assert(isCanonical(Name) && "Expected canonical MDString"); 783 assert(isCanonical(GetterName) && "Expected canonical MDString"); 784 assert(isCanonical(SetterName) && "Expected canonical MDString"); 785 DEFINE_GETIMPL_LOOKUP(DIObjCProperty, (Name, File, Line, GetterName, 786 SetterName, Attributes, Type)); 787 Metadata *Ops[] = {Name, File, GetterName, SetterName, Type}; 788 DEFINE_GETIMPL_STORE(DIObjCProperty, (Line, Attributes), Ops); 789 } 790 791 DIImportedEntity *DIImportedEntity::getImpl(LLVMContext &Context, unsigned Tag, 792 Metadata *Scope, Metadata *Entity, 793 Metadata *File, unsigned Line, 794 MDString *Name, StorageType Storage, 795 bool ShouldCreate) { 796 assert(isCanonical(Name) && "Expected canonical MDString"); 797 DEFINE_GETIMPL_LOOKUP(DIImportedEntity, 798 (Tag, Scope, Entity, File, Line, Name)); 799 Metadata *Ops[] = {Scope, Entity, Name, File}; 800 DEFINE_GETIMPL_STORE(DIImportedEntity, (Tag, Line), Ops); 801 } 802 803 DIMacro *DIMacro::getImpl(LLVMContext &Context, unsigned MIType, 804 unsigned Line, MDString *Name, MDString *Value, 805 StorageType Storage, bool ShouldCreate) { 806 assert(isCanonical(Name) && "Expected canonical MDString"); 807 DEFINE_GETIMPL_LOOKUP(DIMacro, (MIType, Line, Name, Value)); 808 Metadata *Ops[] = { Name, Value }; 809 DEFINE_GETIMPL_STORE(DIMacro, (MIType, Line), Ops); 810 } 811 812 DIMacroFile *DIMacroFile::getImpl(LLVMContext &Context, unsigned MIType, 813 unsigned Line, Metadata *File, 814 Metadata *Elements, StorageType Storage, 815 bool ShouldCreate) { 816 DEFINE_GETIMPL_LOOKUP(DIMacroFile, 817 (MIType, Line, File, Elements)); 818 Metadata *Ops[] = { File, Elements }; 819 DEFINE_GETIMPL_STORE(DIMacroFile, (MIType, Line), Ops); 820 } 821 822