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 DIExpression *DIExpression::createFragmentExpression(const DIExpression *Expr,
728                                                      unsigned OffsetInBits,
729                                                      unsigned SizeInBits) {
730   SmallVector<uint64_t, 8> Ops;
731   // Copy over the expression, but leave off any trailing DW_OP_LLVM_fragment.
732   if (Expr) {
733     for (auto Op : Expr->expr_ops()) {
734       if (Op.getOp() == dwarf::DW_OP_LLVM_fragment) {
735         // Make the new offset point into the existing fragment.
736         uint64_t FragmentOffsetInBits = Op.getArg(0);
737         // Op.getArg(0) is FragmentOffsetInBits.
738         // Op.getArg(1) is FragmentSizeInBits.
739         assert((OffsetInBits + SizeInBits <= Op.getArg(0) + Op.getArg(1)) &&
740                "new fragment outside of original fragment");
741         OffsetInBits += FragmentOffsetInBits;
742         break;
743       }
744       Ops.push_back(Op.getOp());
745       for (unsigned I = 0; I < Op.getNumArgs(); ++I)
746         Ops.push_back(Op.getArg(I));
747     }
748   }
749   Ops.push_back(dwarf::DW_OP_LLVM_fragment);
750   Ops.push_back(OffsetInBits);
751   Ops.push_back(SizeInBits);
752   return DIExpression::get(Expr->getContext(), Ops);
753 }
754 
755 bool DIExpression::isConstant() const {
756   // Recognize DW_OP_constu C DW_OP_stack_value (DW_OP_LLVM_fragment Len Ofs)?.
757   if (getNumElements() != 3 && getNumElements() != 6)
758     return false;
759   if (getElement(0) != dwarf::DW_OP_constu ||
760       getElement(2) != dwarf::DW_OP_stack_value)
761     return false;
762   if (getNumElements() == 6 && getElement(3) != dwarf::DW_OP_LLVM_fragment)
763     return false;
764   return true;
765 }
766 
767 DIGlobalVariableExpression *
768 DIGlobalVariableExpression::getImpl(LLVMContext &Context, Metadata *Variable,
769                                     Metadata *Expression, StorageType Storage,
770                                     bool ShouldCreate) {
771   DEFINE_GETIMPL_LOOKUP(DIGlobalVariableExpression, (Variable, Expression));
772   Metadata *Ops[] = {Variable, Expression};
773   DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIGlobalVariableExpression, Ops);
774 }
775 
776 DIObjCProperty *DIObjCProperty::getImpl(
777     LLVMContext &Context, MDString *Name, Metadata *File, unsigned Line,
778     MDString *GetterName, MDString *SetterName, unsigned Attributes,
779     Metadata *Type, StorageType Storage, bool ShouldCreate) {
780   assert(isCanonical(Name) && "Expected canonical MDString");
781   assert(isCanonical(GetterName) && "Expected canonical MDString");
782   assert(isCanonical(SetterName) && "Expected canonical MDString");
783   DEFINE_GETIMPL_LOOKUP(DIObjCProperty, (Name, File, Line, GetterName,
784                                          SetterName, Attributes, Type));
785   Metadata *Ops[] = {Name, File, GetterName, SetterName, Type};
786   DEFINE_GETIMPL_STORE(DIObjCProperty, (Line, Attributes), Ops);
787 }
788 
789 DIImportedEntity *DIImportedEntity::getImpl(LLVMContext &Context, unsigned Tag,
790                                             Metadata *Scope, Metadata *Entity,
791                                             Metadata *File, unsigned Line,
792                                             MDString *Name, StorageType Storage,
793                                             bool ShouldCreate) {
794   assert(isCanonical(Name) && "Expected canonical MDString");
795   DEFINE_GETIMPL_LOOKUP(DIImportedEntity,
796                         (Tag, Scope, Entity, File, Line, Name));
797   Metadata *Ops[] = {Scope, Entity, Name, File};
798   DEFINE_GETIMPL_STORE(DIImportedEntity, (Tag, Line), Ops);
799 }
800 
801 DIMacro *DIMacro::getImpl(LLVMContext &Context, unsigned MIType,
802                           unsigned Line, MDString *Name, MDString *Value,
803                           StorageType Storage, bool ShouldCreate) {
804   assert(isCanonical(Name) && "Expected canonical MDString");
805   DEFINE_GETIMPL_LOOKUP(DIMacro, (MIType, Line, Name, Value));
806   Metadata *Ops[] = { Name, Value };
807   DEFINE_GETIMPL_STORE(DIMacro, (MIType, Line), Ops);
808 }
809 
810 DIMacroFile *DIMacroFile::getImpl(LLVMContext &Context, unsigned MIType,
811                                   unsigned Line, Metadata *File,
812                                   Metadata *Elements, StorageType Storage,
813                                   bool ShouldCreate) {
814   DEFINE_GETIMPL_LOOKUP(DIMacroFile,
815                         (MIType, Line, File, Elements));
816   Metadata *Ops[] = { File, Elements };
817   DEFINE_GETIMPL_STORE(DIMacroFile, (MIType, Line), Ops);
818 }
819 
820