lib/IR/DebugInfoMetadata.cpp

   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