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