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