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/Function.h" 19 20 using namespace llvm; 21 22 DILocation::DILocation(LLVMContext &C, StorageType Storage, unsigned Line, 23 unsigned Column, ArrayRef<Metadata *> MDs) 24 : MDNode(C, DILocationKind, Storage, MDs) { 25 assert((MDs.size() == 1 || MDs.size() == 2) && 26 "Expected a scope and optional inlined-at"); 27 28 // Set line and column. 29 assert(Column < (1u << 16) && "Expected 16-bit column"); 30 31 SubclassData32 = Line; 32 SubclassData16 = Column; 33 } 34 35 static void adjustColumn(unsigned &Column) { 36 // Set to unknown on overflow. We only have 16 bits to play with here. 37 if (Column >= (1u << 16)) 38 Column = 0; 39 } 40 41 DILocation *DILocation::getImpl(LLVMContext &Context, unsigned Line, 42 unsigned Column, Metadata *Scope, 43 Metadata *InlinedAt, StorageType Storage, 44 bool ShouldCreate) { 45 // Fixup column. 46 adjustColumn(Column); 47 48 if (Storage == Uniqued) { 49 if (auto *N = 50 getUniqued(Context.pImpl->DILocations, 51 DILocationInfo::KeyTy(Line, Column, Scope, InlinedAt))) 52 return N; 53 if (!ShouldCreate) 54 return nullptr; 55 } else { 56 assert(ShouldCreate && "Expected non-uniqued nodes to always be created"); 57 } 58 59 SmallVector<Metadata *, 2> Ops; 60 Ops.push_back(Scope); 61 if (InlinedAt) 62 Ops.push_back(InlinedAt); 63 return storeImpl(new (Ops.size()) 64 DILocation(Context, Storage, Line, Column, Ops), 65 Storage, Context.pImpl->DILocations); 66 } 67 68 unsigned DINode::getFlag(StringRef Flag) { 69 return StringSwitch<unsigned>(Flag) 70 #define HANDLE_DI_FLAG(ID, NAME) .Case("DIFlag" #NAME, Flag##NAME) 71 #include "llvm/IR/DebugInfoFlags.def" 72 .Default(0); 73 } 74 75 const char *DINode::getFlagString(unsigned Flag) { 76 switch (Flag) { 77 default: 78 return ""; 79 #define HANDLE_DI_FLAG(ID, NAME) \ 80 case Flag##NAME: \ 81 return "DIFlag" #NAME; 82 #include "llvm/IR/DebugInfoFlags.def" 83 } 84 } 85 86 unsigned DINode::splitFlags(unsigned Flags, 87 SmallVectorImpl<unsigned> &SplitFlags) { 88 // Accessibility flags need to be specially handled, since they're packed 89 // together. 90 if (unsigned A = Flags & FlagAccessibility) { 91 if (A == FlagPrivate) 92 SplitFlags.push_back(FlagPrivate); 93 else if (A == FlagProtected) 94 SplitFlags.push_back(FlagProtected); 95 else 96 SplitFlags.push_back(FlagPublic); 97 Flags &= ~A; 98 } 99 100 #define HANDLE_DI_FLAG(ID, NAME) \ 101 if (unsigned Bit = Flags & ID) { \ 102 SplitFlags.push_back(Bit); \ 103 Flags &= ~Bit; \ 104 } 105 #include "llvm/IR/DebugInfoFlags.def" 106 107 return Flags; 108 } 109 110 DIScopeRef DIScope::getScope() const { 111 if (auto *T = dyn_cast<DIType>(this)) 112 return T->getScope(); 113 114 if (auto *SP = dyn_cast<DISubprogram>(this)) 115 return SP->getScope(); 116 117 if (auto *LB = dyn_cast<DILexicalBlockBase>(this)) 118 return LB->getScope(); 119 120 if (auto *NS = dyn_cast<DINamespace>(this)) 121 return NS->getScope(); 122 123 if (auto *M = dyn_cast<DIModule>(this)) 124 return M->getScope(); 125 126 assert((isa<DIFile>(this) || isa<DICompileUnit>(this)) && 127 "Unhandled type of scope."); 128 return nullptr; 129 } 130 131 StringRef DIScope::getName() const { 132 if (auto *T = dyn_cast<DIType>(this)) 133 return T->getName(); 134 if (auto *SP = dyn_cast<DISubprogram>(this)) 135 return SP->getName(); 136 if (auto *NS = dyn_cast<DINamespace>(this)) 137 return NS->getName(); 138 if (auto *M = dyn_cast<DIModule>(this)) 139 return M->getName(); 140 assert((isa<DILexicalBlockBase>(this) || isa<DIFile>(this) || 141 isa<DICompileUnit>(this)) && 142 "Unhandled type of scope."); 143 return ""; 144 } 145 146 #ifndef NDEBUG 147 static bool isCanonical(const MDString *S) { 148 return !S || !S->getString().empty(); 149 } 150 #endif 151 152 GenericDINode *GenericDINode::getImpl(LLVMContext &Context, unsigned Tag, 153 MDString *Header, 154 ArrayRef<Metadata *> DwarfOps, 155 StorageType Storage, bool ShouldCreate) { 156 unsigned Hash = 0; 157 if (Storage == Uniqued) { 158 GenericDINodeInfo::KeyTy Key(Tag, Header, DwarfOps); 159 if (auto *N = getUniqued(Context.pImpl->GenericDINodes, Key)) 160 return N; 161 if (!ShouldCreate) 162 return nullptr; 163 Hash = Key.getHash(); 164 } else { 165 assert(ShouldCreate && "Expected non-uniqued nodes to always be created"); 166 } 167 168 // Use a nullptr for empty headers. 169 assert(isCanonical(Header) && "Expected canonical MDString"); 170 Metadata *PreOps[] = {Header}; 171 return storeImpl(new (DwarfOps.size() + 1) GenericDINode( 172 Context, Storage, Hash, Tag, PreOps, DwarfOps), 173 Storage, Context.pImpl->GenericDINodes); 174 } 175 176 void GenericDINode::recalculateHash() { 177 setHash(GenericDINodeInfo::KeyTy::calculateHash(this)); 178 } 179 180 #define UNWRAP_ARGS_IMPL(...) __VA_ARGS__ 181 #define UNWRAP_ARGS(ARGS) UNWRAP_ARGS_IMPL ARGS 182 #define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS) \ 183 do { \ 184 if (Storage == Uniqued) { \ 185 if (auto *N = getUniqued(Context.pImpl->CLASS##s, \ 186 CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS)))) \ 187 return N; \ 188 if (!ShouldCreate) \ 189 return nullptr; \ 190 } else { \ 191 assert(ShouldCreate && \ 192 "Expected non-uniqued nodes to always be created"); \ 193 } \ 194 } while (false) 195 #define DEFINE_GETIMPL_STORE(CLASS, ARGS, OPS) \ 196 return storeImpl(new (array_lengthof(OPS)) \ 197 CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \ 198 Storage, Context.pImpl->CLASS##s) 199 #define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS) \ 200 return storeImpl(new (0u) CLASS(Context, Storage, UNWRAP_ARGS(ARGS)), \ 201 Storage, Context.pImpl->CLASS##s) 202 #define DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(CLASS, OPS) \ 203 return storeImpl(new (array_lengthof(OPS)) CLASS(Context, Storage, OPS), \ 204 Storage, Context.pImpl->CLASS##s) 205 206 DISubrange *DISubrange::getImpl(LLVMContext &Context, int64_t Count, int64_t Lo, 207 StorageType Storage, bool ShouldCreate) { 208 DEFINE_GETIMPL_LOOKUP(DISubrange, (Count, Lo)); 209 DEFINE_GETIMPL_STORE_NO_OPS(DISubrange, (Count, Lo)); 210 } 211 212 DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, int64_t Value, 213 MDString *Name, StorageType Storage, 214 bool ShouldCreate) { 215 assert(isCanonical(Name) && "Expected canonical MDString"); 216 DEFINE_GETIMPL_LOOKUP(DIEnumerator, (Value, Name)); 217 Metadata *Ops[] = {Name}; 218 DEFINE_GETIMPL_STORE(DIEnumerator, (Value), Ops); 219 } 220 221 DIBasicType *DIBasicType::getImpl(LLVMContext &Context, unsigned Tag, 222 MDString *Name, uint64_t SizeInBits, 223 uint64_t AlignInBits, unsigned Encoding, 224 StorageType Storage, bool ShouldCreate) { 225 assert(isCanonical(Name) && "Expected canonical MDString"); 226 DEFINE_GETIMPL_LOOKUP(DIBasicType, 227 (Tag, Name, SizeInBits, AlignInBits, Encoding)); 228 Metadata *Ops[] = {nullptr, nullptr, Name}; 229 DEFINE_GETIMPL_STORE(DIBasicType, (Tag, SizeInBits, AlignInBits, Encoding), 230 Ops); 231 } 232 233 DIDerivedType *DIDerivedType::getImpl( 234 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File, 235 unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, 236 uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags, 237 Metadata *ExtraData, StorageType Storage, bool ShouldCreate) { 238 assert(isCanonical(Name) && "Expected canonical MDString"); 239 DEFINE_GETIMPL_LOOKUP(DIDerivedType, 240 (Tag, Name, File, Line, Scope, BaseType, SizeInBits, 241 AlignInBits, OffsetInBits, Flags, ExtraData)); 242 Metadata *Ops[] = {File, Scope, Name, BaseType, ExtraData}; 243 DEFINE_GETIMPL_STORE( 244 DIDerivedType, (Tag, Line, SizeInBits, AlignInBits, OffsetInBits, Flags), 245 Ops); 246 } 247 248 DICompositeType *DICompositeType::getImpl( 249 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File, 250 unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, 251 uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags, 252 Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder, 253 Metadata *TemplateParams, MDString *Identifier, StorageType Storage, 254 bool ShouldCreate) { 255 assert(isCanonical(Name) && "Expected canonical MDString"); 256 257 // Keep this in sync with buildODRType. 258 DEFINE_GETIMPL_LOOKUP( 259 DICompositeType, (Tag, Name, File, Line, Scope, BaseType, SizeInBits, 260 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, 261 VTableHolder, TemplateParams, Identifier)); 262 Metadata *Ops[] = {File, Scope, Name, BaseType, 263 Elements, VTableHolder, TemplateParams, Identifier}; 264 DEFINE_GETIMPL_STORE(DICompositeType, (Tag, Line, RuntimeLang, SizeInBits, 265 AlignInBits, OffsetInBits, Flags), 266 Ops); 267 } 268 269 DICompositeType *DICompositeType::buildODRType( 270 LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name, 271 Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, 272 uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits, 273 unsigned Flags, Metadata *Elements, unsigned RuntimeLang, 274 Metadata *VTableHolder, Metadata *TemplateParams) { 275 assert(!Identifier.getString().empty() && "Expected valid identifier"); 276 if (!Context.isODRUniquingDebugTypes()) 277 return nullptr; 278 auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier]; 279 if (!CT) 280 return CT = DICompositeType::getDistinct( 281 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, 282 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, 283 VTableHolder, TemplateParams, &Identifier); 284 285 // Only mutate CT if it's a forward declaration and the new operands aren't. 286 assert(CT->getRawIdentifier() == &Identifier && "Wrong ODR identifier?"); 287 if (!CT->isForwardDecl() || (Flags & DINode::FlagFwdDecl)) 288 return CT; 289 290 // Mutate CT in place. Keep this in sync with getImpl. 291 CT->mutate(Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits, 292 Flags); 293 Metadata *Ops[] = {File, Scope, Name, BaseType, 294 Elements, VTableHolder, TemplateParams, &Identifier}; 295 assert((std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() && 296 "Mismatched number of operands"); 297 for (unsigned I = 0, E = CT->getNumOperands(); I != E; ++I) 298 if (Ops[I] != CT->getOperand(I)) 299 CT->setOperand(I, Ops[I]); 300 return CT; 301 } 302 303 DICompositeType *DICompositeType::getODRType( 304 LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name, 305 Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, 306 uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits, 307 unsigned Flags, Metadata *Elements, unsigned RuntimeLang, 308 Metadata *VTableHolder, Metadata *TemplateParams) { 309 assert(!Identifier.getString().empty() && "Expected valid identifier"); 310 if (!Context.isODRUniquingDebugTypes()) 311 return nullptr; 312 auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier]; 313 if (!CT) 314 CT = DICompositeType::getDistinct( 315 Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, 316 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder, 317 TemplateParams, &Identifier); 318 return CT; 319 } 320 321 DICompositeType *DICompositeType::getODRTypeIfExists(LLVMContext &Context, 322 MDString &Identifier) { 323 assert(!Identifier.getString().empty() && "Expected valid identifier"); 324 if (!Context.isODRUniquingDebugTypes()) 325 return nullptr; 326 return Context.pImpl->DITypeMap->lookup(&Identifier); 327 } 328 329 DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context, 330 unsigned Flags, Metadata *TypeArray, 331 StorageType Storage, 332 bool ShouldCreate) { 333 DEFINE_GETIMPL_LOOKUP(DISubroutineType, (Flags, TypeArray)); 334 Metadata *Ops[] = {nullptr, nullptr, nullptr, TypeArray}; 335 DEFINE_GETIMPL_STORE(DISubroutineType, (Flags), Ops); 336 } 337 338 DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename, 339 MDString *Directory, StorageType Storage, 340 bool ShouldCreate) { 341 assert(isCanonical(Filename) && "Expected canonical MDString"); 342 assert(isCanonical(Directory) && "Expected canonical MDString"); 343 DEFINE_GETIMPL_LOOKUP(DIFile, (Filename, Directory)); 344 Metadata *Ops[] = {Filename, Directory}; 345 DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIFile, Ops); 346 } 347 348 DICompileUnit *DICompileUnit::getImpl( 349 LLVMContext &Context, unsigned SourceLanguage, Metadata *File, 350 MDString *Producer, bool IsOptimized, MDString *Flags, 351 unsigned RuntimeVersion, MDString *SplitDebugFilename, 352 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes, 353 Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros, 354 uint64_t DWOId, StorageType Storage, bool ShouldCreate) { 355 assert(Storage != Uniqued && "Cannot unique DICompileUnit"); 356 assert(isCanonical(Producer) && "Expected canonical MDString"); 357 assert(isCanonical(Flags) && "Expected canonical MDString"); 358 assert(isCanonical(SplitDebugFilename) && "Expected canonical MDString"); 359 360 Metadata *Ops[] = { 361 File, Producer, Flags, SplitDebugFilename, 362 EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities, 363 Macros}; 364 return storeImpl(new (array_lengthof(Ops)) DICompileUnit( 365 Context, Storage, SourceLanguage, IsOptimized, 366 RuntimeVersion, EmissionKind, DWOId, Ops), 367 Storage); 368 } 369 370 Optional<DICompileUnit::DebugEmissionKind> 371 DICompileUnit::getEmissionKind(StringRef Str) { 372 return StringSwitch<Optional<DebugEmissionKind>>(Str) 373 .Case("NoDebug", NoDebug) 374 .Case("FullDebug", FullDebug) 375 .Case("LineTablesOnly", LineTablesOnly) 376 .Default(None); 377 } 378 379 const char *DICompileUnit::EmissionKindString(DebugEmissionKind EK) { 380 switch (EK) { 381 case NoDebug: return "NoDebug"; 382 case FullDebug: return "FullDebug"; 383 case LineTablesOnly: return "LineTablesOnly"; 384 } 385 return nullptr; 386 } 387 388 DISubprogram *DILocalScope::getSubprogram() const { 389 if (auto *Block = dyn_cast<DILexicalBlockBase>(this)) 390 return Block->getScope()->getSubprogram(); 391 return const_cast<DISubprogram *>(cast<DISubprogram>(this)); 392 } 393 394 DILocalScope *DILocalScope::getNonLexicalBlockFileScope() const { 395 if (auto *File = dyn_cast<DILexicalBlockFile>(this)) 396 return File->getScope()->getNonLexicalBlockFileScope(); 397 return const_cast<DILocalScope *>(this); 398 } 399 400 DISubprogram *DISubprogram::getImpl( 401 LLVMContext &Context, Metadata *Scope, MDString *Name, 402 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type, 403 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine, 404 Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex, 405 unsigned Flags, bool IsOptimized, Metadata *Unit, Metadata *TemplateParams, 406 Metadata *Declaration, Metadata *Variables, StorageType Storage, 407 bool ShouldCreate) { 408 assert(isCanonical(Name) && "Expected canonical MDString"); 409 assert(isCanonical(LinkageName) && "Expected canonical MDString"); 410 DEFINE_GETIMPL_LOOKUP(DISubprogram, 411 (Scope, Name, LinkageName, File, Line, Type, 412 IsLocalToUnit, IsDefinition, ScopeLine, ContainingType, 413 Virtuality, VirtualIndex, Flags, IsOptimized, Unit, 414 TemplateParams, Declaration, Variables)); 415 Metadata *Ops[] = {File, Scope, Name, Name, 416 LinkageName, Type, ContainingType, Unit, 417 TemplateParams, Declaration, Variables}; 418 DEFINE_GETIMPL_STORE(DISubprogram, 419 (Line, ScopeLine, Virtuality, VirtualIndex, Flags, 420 IsLocalToUnit, IsDefinition, IsOptimized), 421 Ops); 422 } 423 424 bool DISubprogram::describes(const Function *F) const { 425 assert(F && "Invalid function"); 426 if (F->getSubprogram() == this) 427 return true; 428 StringRef Name = getLinkageName(); 429 if (Name.empty()) 430 Name = getName(); 431 return F->getName() == Name; 432 } 433 434 DILexicalBlock *DILexicalBlock::getImpl(LLVMContext &Context, Metadata *Scope, 435 Metadata *File, unsigned Line, 436 unsigned Column, StorageType Storage, 437 bool ShouldCreate) { 438 // Fixup column. 439 adjustColumn(Column); 440 441 assert(Scope && "Expected scope"); 442 DEFINE_GETIMPL_LOOKUP(DILexicalBlock, (Scope, File, Line, Column)); 443 Metadata *Ops[] = {File, Scope}; 444 DEFINE_GETIMPL_STORE(DILexicalBlock, (Line, Column), Ops); 445 } 446 447 DILexicalBlockFile *DILexicalBlockFile::getImpl(LLVMContext &Context, 448 Metadata *Scope, Metadata *File, 449 unsigned Discriminator, 450 StorageType Storage, 451 bool ShouldCreate) { 452 assert(Scope && "Expected scope"); 453 DEFINE_GETIMPL_LOOKUP(DILexicalBlockFile, (Scope, File, Discriminator)); 454 Metadata *Ops[] = {File, Scope}; 455 DEFINE_GETIMPL_STORE(DILexicalBlockFile, (Discriminator), Ops); 456 } 457 458 DINamespace *DINamespace::getImpl(LLVMContext &Context, Metadata *Scope, 459 Metadata *File, MDString *Name, unsigned Line, 460 StorageType Storage, bool ShouldCreate) { 461 assert(isCanonical(Name) && "Expected canonical MDString"); 462 DEFINE_GETIMPL_LOOKUP(DINamespace, (Scope, File, Name, Line)); 463 Metadata *Ops[] = {File, Scope, Name}; 464 DEFINE_GETIMPL_STORE(DINamespace, (Line), Ops); 465 } 466 467 DIModule *DIModule::getImpl(LLVMContext &Context, Metadata *Scope, 468 MDString *Name, MDString *ConfigurationMacros, 469 MDString *IncludePath, MDString *ISysRoot, 470 StorageType Storage, bool ShouldCreate) { 471 assert(isCanonical(Name) && "Expected canonical MDString"); 472 DEFINE_GETIMPL_LOOKUP( 473 DIModule, (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot)); 474 Metadata *Ops[] = {Scope, Name, ConfigurationMacros, IncludePath, ISysRoot}; 475 DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIModule, Ops); 476 } 477 478 DITemplateTypeParameter *DITemplateTypeParameter::getImpl(LLVMContext &Context, 479 MDString *Name, 480 Metadata *Type, 481 StorageType Storage, 482 bool ShouldCreate) { 483 assert(isCanonical(Name) && "Expected canonical MDString"); 484 DEFINE_GETIMPL_LOOKUP(DITemplateTypeParameter, (Name, Type)); 485 Metadata *Ops[] = {Name, Type}; 486 DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DITemplateTypeParameter, Ops); 487 } 488 489 DITemplateValueParameter *DITemplateValueParameter::getImpl( 490 LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *Type, 491 Metadata *Value, StorageType Storage, bool ShouldCreate) { 492 assert(isCanonical(Name) && "Expected canonical MDString"); 493 DEFINE_GETIMPL_LOOKUP(DITemplateValueParameter, (Tag, Name, Type, Value)); 494 Metadata *Ops[] = {Name, Type, Value}; 495 DEFINE_GETIMPL_STORE(DITemplateValueParameter, (Tag), Ops); 496 } 497 498 DIGlobalVariable * 499 DIGlobalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name, 500 MDString *LinkageName, Metadata *File, unsigned Line, 501 Metadata *Type, bool IsLocalToUnit, bool IsDefinition, 502 Metadata *Variable, 503 Metadata *StaticDataMemberDeclaration, 504 StorageType Storage, bool ShouldCreate) { 505 assert(isCanonical(Name) && "Expected canonical MDString"); 506 assert(isCanonical(LinkageName) && "Expected canonical MDString"); 507 DEFINE_GETIMPL_LOOKUP(DIGlobalVariable, 508 (Scope, Name, LinkageName, File, Line, Type, 509 IsLocalToUnit, IsDefinition, Variable, 510 StaticDataMemberDeclaration)); 511 Metadata *Ops[] = {Scope, Name, File, Type, 512 Name, LinkageName, Variable, StaticDataMemberDeclaration}; 513 DEFINE_GETIMPL_STORE(DIGlobalVariable, (Line, IsLocalToUnit, IsDefinition), 514 Ops); 515 } 516 517 DILocalVariable *DILocalVariable::getImpl(LLVMContext &Context, Metadata *Scope, 518 MDString *Name, Metadata *File, 519 unsigned Line, Metadata *Type, 520 unsigned Arg, unsigned Flags, 521 StorageType Storage, 522 bool ShouldCreate) { 523 // 64K ought to be enough for any frontend. 524 assert(Arg <= UINT16_MAX && "Expected argument number to fit in 16-bits"); 525 526 assert(Scope && "Expected scope"); 527 assert(isCanonical(Name) && "Expected canonical MDString"); 528 DEFINE_GETIMPL_LOOKUP(DILocalVariable, 529 (Scope, Name, File, Line, Type, Arg, Flags)); 530 Metadata *Ops[] = {Scope, Name, File, Type}; 531 DEFINE_GETIMPL_STORE(DILocalVariable, (Line, Arg, Flags), Ops); 532 } 533 534 DIExpression *DIExpression::getImpl(LLVMContext &Context, 535 ArrayRef<uint64_t> Elements, 536 StorageType Storage, bool ShouldCreate) { 537 DEFINE_GETIMPL_LOOKUP(DIExpression, (Elements)); 538 DEFINE_GETIMPL_STORE_NO_OPS(DIExpression, (Elements)); 539 } 540 541 unsigned DIExpression::ExprOperand::getSize() const { 542 switch (getOp()) { 543 case dwarf::DW_OP_bit_piece: 544 return 3; 545 case dwarf::DW_OP_plus: 546 case dwarf::DW_OP_minus: 547 return 2; 548 default: 549 return 1; 550 } 551 } 552 553 bool DIExpression::isValid() const { 554 for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) { 555 // Check that there's space for the operand. 556 if (I->get() + I->getSize() > E->get()) 557 return false; 558 559 // Check that the operand is valid. 560 switch (I->getOp()) { 561 default: 562 return false; 563 case dwarf::DW_OP_bit_piece: 564 // Piece expressions must be at the end. 565 return I->get() + I->getSize() == E->get(); 566 case dwarf::DW_OP_plus: 567 case dwarf::DW_OP_minus: 568 case dwarf::DW_OP_deref: 569 break; 570 } 571 } 572 return true; 573 } 574 575 bool DIExpression::isBitPiece() const { 576 assert(isValid() && "Expected valid expression"); 577 if (unsigned N = getNumElements()) 578 if (N >= 3) 579 return getElement(N - 3) == dwarf::DW_OP_bit_piece; 580 return false; 581 } 582 583 uint64_t DIExpression::getBitPieceOffset() const { 584 assert(isBitPiece() && "Expected bit piece"); 585 return getElement(getNumElements() - 2); 586 } 587 588 uint64_t DIExpression::getBitPieceSize() const { 589 assert(isBitPiece() && "Expected bit piece"); 590 return getElement(getNumElements() - 1); 591 } 592 593 DIObjCProperty *DIObjCProperty::getImpl( 594 LLVMContext &Context, MDString *Name, Metadata *File, unsigned Line, 595 MDString *GetterName, MDString *SetterName, unsigned Attributes, 596 Metadata *Type, StorageType Storage, bool ShouldCreate) { 597 assert(isCanonical(Name) && "Expected canonical MDString"); 598 assert(isCanonical(GetterName) && "Expected canonical MDString"); 599 assert(isCanonical(SetterName) && "Expected canonical MDString"); 600 DEFINE_GETIMPL_LOOKUP(DIObjCProperty, (Name, File, Line, GetterName, 601 SetterName, Attributes, Type)); 602 Metadata *Ops[] = {Name, File, GetterName, SetterName, Type}; 603 DEFINE_GETIMPL_STORE(DIObjCProperty, (Line, Attributes), Ops); 604 } 605 606 DIImportedEntity *DIImportedEntity::getImpl(LLVMContext &Context, unsigned Tag, 607 Metadata *Scope, Metadata *Entity, 608 unsigned Line, MDString *Name, 609 StorageType Storage, 610 bool ShouldCreate) { 611 assert(isCanonical(Name) && "Expected canonical MDString"); 612 DEFINE_GETIMPL_LOOKUP(DIImportedEntity, (Tag, Scope, Entity, Line, Name)); 613 Metadata *Ops[] = {Scope, Entity, Name}; 614 DEFINE_GETIMPL_STORE(DIImportedEntity, (Tag, Line), Ops); 615 } 616 617 DIMacro *DIMacro::getImpl(LLVMContext &Context, unsigned MIType, 618 unsigned Line, MDString *Name, MDString *Value, 619 StorageType Storage, bool ShouldCreate) { 620 assert(isCanonical(Name) && "Expected canonical MDString"); 621 DEFINE_GETIMPL_LOOKUP(DIMacro, (MIType, Line, Name, Value)); 622 Metadata *Ops[] = { Name, Value }; 623 DEFINE_GETIMPL_STORE(DIMacro, (MIType, Line), Ops); 624 } 625 626 DIMacroFile *DIMacroFile::getImpl(LLVMContext &Context, unsigned MIType, 627 unsigned Line, Metadata *File, 628 Metadata *Elements, StorageType Storage, 629 bool ShouldCreate) { 630 DEFINE_GETIMPL_LOOKUP(DIMacroFile, 631 (MIType, Line, File, Elements)); 632 Metadata *Ops[] = { File, Elements }; 633 DEFINE_GETIMPL_STORE(DIMacroFile, (MIType, Line), Ops); 634 } 635 636