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