DIBuilder: Extract DIHeaderFieldIterator::getNumber(), NFC
[opencl/llvm.git] / include / llvm / IR / DebugInfo.h
1 //===- DebugInfo.h - Debug Information Helpers ------------------*- C++ -*-===//
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 defines a bunch of datatypes that are useful for creating and
11 // walking debug info in LLVM IR form. They essentially provide wrappers around
12 // the information in the global variables that's needed when constructing the
13 // DWARF information.
14 //
15 //===----------------------------------------------------------------------===//
17 #ifndef LLVM_IR_DEBUGINFO_H
18 #define LLVM_IR_DEBUGINFO_H
20 #include "llvm/ADT/DenseMap.h"
21 #include "llvm/ADT/SmallPtrSet.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/ADT/StringRef.h"
24 #include "llvm/ADT/iterator_range.h"
25 #include "llvm/IR/Metadata.h"
26 #include "llvm/Support/Casting.h"
27 #include "llvm/Support/Dwarf.h"
28 #include "llvm/Support/ErrorHandling.h"
29 #include <iterator>
31 namespace llvm {
32 class BasicBlock;
33 class Constant;
34 class Function;
35 class GlobalVariable;
36 class Module;
37 class Type;
38 class Value;
39 class DbgDeclareInst;
40 class DbgValueInst;
41 class Instruction;
42 class Metadata;
43 class MDNode;
44 class MDString;
45 class NamedMDNode;
46 class LLVMContext;
47 class raw_ostream;
49 class DIFile;
50 class DISubprogram;
51 class DILexicalBlock;
52 class DILexicalBlockFile;
53 class DIVariable;
54 class DIType;
55 class DIScope;
56 class DIObjCProperty;
58 /// \brief Maps from type identifier to the actual MDNode.
59 typedef DenseMap<const MDString *, MDNode *> DITypeIdentifierMap;
61 class DIHeaderFieldIterator
62     : public std::iterator<std::forward_iterator_tag, StringRef, std::ptrdiff_t,
63                            const StringRef *, StringRef> {
64   StringRef Header;
65   StringRef Current;
67 public:
68   DIHeaderFieldIterator() {}
69   DIHeaderFieldIterator(StringRef Header)
70       : Header(Header), Current(Header.slice(0, Header.find('\0'))) {}
71   StringRef operator*() const { return Current; }
72   const StringRef * operator->() const { return &Current; }
73   DIHeaderFieldIterator &operator++() {
74     increment();
75     return *this;
76   }
77   DIHeaderFieldIterator operator++(int) {
78     DIHeaderFieldIterator X(*this);
79     increment();
80     return X;
81   }
82   bool operator==(const DIHeaderFieldIterator &X) const {
83     return Current.data() == X.Current.data();
84   }
85   bool operator!=(const DIHeaderFieldIterator &X) const {
86     return !(*this == X);
87   }
89   StringRef getHeader() const { return Header; }
90   StringRef getCurrent() const { return Current; }
91   StringRef getPrefix() const {
92     if (Current.begin() == Header.begin())
93       return StringRef();
94     return Header.slice(0, Current.begin() - Header.begin() - 1);
95   }
96   StringRef getSuffix() const {
97     if (Current.end() == Header.end())
98       return StringRef();
99     return Header.slice(Current.end() - Header.begin() + 1, StringRef::npos);
100   }
102   /// \brief Get the current field as a number.
103   ///
104   /// Convert the current field into a number.  Return \c 0 on error.
105   template <class T> T getNumber() const {
106     T Int;
107     if (getCurrent().getAsInteger(0, Int))
108       return 0;
109     return Int;
110   }
112 private:
113   void increment() {
114     assert(Current.data() != nullptr && "Cannot increment past the end");
115     StringRef Suffix = getSuffix();
116     Current = Suffix.slice(0, Suffix.find('\0'));
117   }
118 };
120 /// \brief A thin wraper around MDNode to access encoded debug info.
121 ///
122 /// This should not be stored in a container, because the underlying MDNode may
123 /// change in certain situations.
124 class DIDescriptor {
125   // Befriends DIRef so DIRef can befriend the protected member
126   // function: getFieldAs<DIRef>.
127   template <typename T> friend class DIRef;
129 public:
130   /// \brief Accessibility flags.
131   ///
132   /// The three accessibility flags are mutually exclusive and rolled together
133   /// in the first two bits.
134   enum {
135     FlagAccessibility     = 1 << 0 | 1 << 1,
136     FlagPrivate           = 1,
137     FlagProtected         = 2,
138     FlagPublic            = 3,
140     FlagFwdDecl           = 1 << 2,
141     FlagAppleBlock        = 1 << 3,
142     FlagBlockByrefStruct  = 1 << 4,
143     FlagVirtual           = 1 << 5,
144     FlagArtificial        = 1 << 6,
145     FlagExplicit          = 1 << 7,
146     FlagPrototyped        = 1 << 8,
147     FlagObjcClassComplete = 1 << 9,
148     FlagObjectPointer     = 1 << 10,
149     FlagVector            = 1 << 11,
150     FlagStaticMember      = 1 << 12,
151     FlagLValueReference   = 1 << 13,
152     FlagRValueReference   = 1 << 14
153   };
155 protected:
156   const MDNode *DbgNode;
158   StringRef getStringField(unsigned Elt) const;
159   unsigned getUnsignedField(unsigned Elt) const {
160     return (unsigned)getUInt64Field(Elt);
161   }
162   uint64_t getUInt64Field(unsigned Elt) const;
163   int64_t getInt64Field(unsigned Elt) const;
164   DIDescriptor getDescriptorField(unsigned Elt) const;
166   template <typename DescTy> DescTy getFieldAs(unsigned Elt) const {
167     return DescTy(getDescriptorField(Elt));
168   }
170   GlobalVariable *getGlobalVariableField(unsigned Elt) const;
171   Constant *getConstantField(unsigned Elt) const;
172   Function *getFunctionField(unsigned Elt) const;
173   void replaceFunctionField(unsigned Elt, Function *F);
175 public:
176   explicit DIDescriptor(const MDNode *N = nullptr) : DbgNode(N) {}
178   bool Verify() const;
180   MDNode *get() const { return const_cast<MDNode *>(DbgNode); }
181   operator MDNode *() const { return get(); }
182   MDNode *operator->() const { return get(); }
184   // An explicit operator bool so that we can do testing of DI values
185   // easily.
186   // FIXME: This operator bool isn't actually protecting anything at the
187   // moment due to the conversion operator above making DIDescriptor nodes
188   // implicitly convertable to bool.
189   LLVM_EXPLICIT operator bool() const { return DbgNode != nullptr; }
191   bool operator==(DIDescriptor Other) const { return DbgNode == Other.DbgNode; }
192   bool operator!=(DIDescriptor Other) const { return !operator==(Other); }
194   StringRef getHeader() const {
195     return getStringField(0);
196   }
198   size_t getNumHeaderFields() const {
199     return std::distance(DIHeaderFieldIterator(getHeader()),
200                          DIHeaderFieldIterator());
201   }
203   DIHeaderFieldIterator getHeaderIterator(unsigned Index) const {
204     // Since callers expect an empty string for out-of-range accesses, we can't
205     // use std::advance() here.
206     for (DIHeaderFieldIterator I(getHeader()), E; I != E; ++I, --Index)
207       if (!Index)
208         return I;
209     return StringRef();
210   }
212   StringRef getHeaderField(unsigned Index) const {
213     return *getHeaderIterator(Index);
214   }
216   template <class T> T getHeaderFieldAs(unsigned Index) const {
217     return getHeaderIterator(Index).getNumber<T>();
218   }
220   uint16_t getTag() const { return getHeaderFieldAs<uint16_t>(0); }
222   bool isDerivedType() const;
223   bool isCompositeType() const;
224   bool isSubroutineType() const;
225   bool isBasicType() const;
226   bool isVariable() const;
227   bool isSubprogram() const;
228   bool isGlobalVariable() const;
229   bool isScope() const;
230   bool isFile() const;
231   bool isCompileUnit() const;
232   bool isNameSpace() const;
233   bool isLexicalBlockFile() const;
234   bool isLexicalBlock() const;
235   bool isSubrange() const;
236   bool isEnumerator() const;
237   bool isType() const;
238   bool isTemplateTypeParameter() const;
239   bool isTemplateValueParameter() const;
240   bool isObjCProperty() const;
241   bool isImportedEntity() const;
242   bool isExpression() const;
244   void print(raw_ostream &OS) const;
245   void dump() const;
247   /// \brief Replace all uses of debug info referenced by this descriptor.
248   void replaceAllUsesWith(LLVMContext &VMContext, DIDescriptor D);
249   void replaceAllUsesWith(MDNode *D);
250 };
252 /// \brief This is used to represent ranges, for array bounds.
253 class DISubrange : public DIDescriptor {
254   friend class DIDescriptor;
255   void printInternal(raw_ostream &OS) const;
257 public:
258   explicit DISubrange(const MDNode *N = nullptr) : DIDescriptor(N) {}
260   int64_t getLo() const { return getHeaderFieldAs<int64_t>(1); }
261   int64_t getCount() const { return getHeaderFieldAs<int64_t>(2); }
262   bool Verify() const;
263 };
265 /// \brief This descriptor holds an array of nodes with type T.
266 template <typename T> class DITypedArray : public DIDescriptor {
267 public:
268   explicit DITypedArray(const MDNode *N = nullptr) : DIDescriptor(N) {}
269   unsigned getNumElements() const {
270     return DbgNode ? DbgNode->getNumOperands() : 0;
271   }
272   T getElement(unsigned Idx) const {
273     return getFieldAs<T>(Idx);
274   }
275 };
277 typedef DITypedArray<DIDescriptor> DIArray;
279 /// \brief A wrapper for an enumerator (e.g. X and Y in 'enum {X,Y}').
280 ///
281 /// FIXME: it seems strange that this doesn't have either a reference to the
282 /// type/precision or a file/line pair for location info.
283 class DIEnumerator : public DIDescriptor {
284   friend class DIDescriptor;
285   void printInternal(raw_ostream &OS) const;
287 public:
288   explicit DIEnumerator(const MDNode *N = nullptr) : DIDescriptor(N) {}
290   StringRef getName() const { return getHeaderField(1); }
291   int64_t getEnumValue() const { return getHeaderFieldAs<int64_t>(2); }
292   bool Verify() const;
293 };
295 template <typename T> class DIRef;
296 typedef DIRef<DIScope> DIScopeRef;
297 typedef DIRef<DIType> DITypeRef;
298 typedef DITypedArray<DITypeRef> DITypeArray;
300 /// \brief A base class for various scopes.
301 ///
302 /// Although, implementation-wise, DIScope is the parent class of most
303 /// other DIxxx classes, including DIType and its descendants, most of
304 /// DIScope's descendants are not a substitutable subtype of
305 /// DIScope. The DIDescriptor::isScope() method only is true for
306 /// DIScopes that are scopes in the strict lexical scope sense
307 /// (DICompileUnit, DISubprogram, etc.), but not for, e.g., a DIType.
308 class DIScope : public DIDescriptor {
309 protected:
310   friend class DIDescriptor;
311   void printInternal(raw_ostream &OS) const;
313 public:
314   explicit DIScope(const MDNode *N = nullptr) : DIDescriptor(N) {}
316   /// \brief Get the parent scope.
317   ///
318   /// Gets the parent scope for this scope node or returns a default
319   /// constructed scope.
320   DIScopeRef getContext() const;
321   /// \brief Get the scope name.
322   ///
323   /// If the scope node has a name, return that, else return an empty string.
324   StringRef getName() const;
325   StringRef getFilename() const;
326   StringRef getDirectory() const;
328   /// \brief Generate a reference to this DIScope.
329   ///
330   /// Uses the type identifier instead of the actual MDNode if possible, to
331   /// help type uniquing.
332   DIScopeRef getRef() const;
333 };
335 /// \brief Represents reference to a DIDescriptor.
336 ///
337 /// Abstracts over direct and identifier-based metadata references.
338 template <typename T> class DIRef {
339   template <typename DescTy>
340   friend DescTy DIDescriptor::getFieldAs(unsigned Elt) const;
341   friend DIScopeRef DIScope::getContext() const;
342   friend DIScopeRef DIScope::getRef() const;
343   friend class DIType;
345   /// \brief Val can be either a MDNode or a MDString.
346   ///
347   /// In the latter, MDString specifies the type identifier.
348   const Metadata *Val;
349   explicit DIRef(const Metadata *V);
351 public:
352   T resolve(const DITypeIdentifierMap &Map) const;
353   StringRef getName() const;
354   operator Metadata *() const { return const_cast<Metadata *>(Val); }
355 };
357 template <typename T>
358 T DIRef<T>::resolve(const DITypeIdentifierMap &Map) const {
359   if (!Val)
360     return T();
362   if (const MDNode *MD = dyn_cast<MDNode>(Val))
363     return T(MD);
365   const MDString *MS = cast<MDString>(Val);
366   // Find the corresponding MDNode.
367   DITypeIdentifierMap::const_iterator Iter = Map.find(MS);
368   assert(Iter != Map.end() && "Identifier not in the type map?");
369   assert(DIDescriptor(Iter->second).isType() &&
370          "MDNode in DITypeIdentifierMap should be a DIType.");
371   return T(Iter->second);
374 template <typename T> StringRef DIRef<T>::getName() const {
375   if (!Val)
376     return StringRef();
378   if (const MDNode *MD = dyn_cast<MDNode>(Val))
379     return T(MD).getName();
381   const MDString *MS = cast<MDString>(Val);
382   return MS->getString();
385 /// \brief Handle fields that are references to DIScopes.
386 template <> DIScopeRef DIDescriptor::getFieldAs<DIScopeRef>(unsigned Elt) const;
387 /// \brief Specialize DIRef constructor for DIScopeRef.
388 template <> DIRef<DIScope>::DIRef(const Metadata *V);
390 /// \brief Handle fields that are references to DITypes.
391 template <> DITypeRef DIDescriptor::getFieldAs<DITypeRef>(unsigned Elt) const;
392 /// \brief Specialize DIRef constructor for DITypeRef.
393 template <> DIRef<DIType>::DIRef(const Metadata *V);
395 /// \briefThis is a wrapper for a type.
396 ///
397 /// FIXME: Types should be factored much better so that CV qualifiers and
398 /// others do not require a huge and empty descriptor full of zeros.
399 class DIType : public DIScope {
400 protected:
401   friend class DIDescriptor;
402   void printInternal(raw_ostream &OS) const;
404 public:
405   explicit DIType(const MDNode *N = nullptr) : DIScope(N) {}
406   operator DITypeRef () const {
407     assert(isType() &&
408            "constructing DITypeRef from an MDNode that is not a type");
409     return DITypeRef(&*getRef());
410   }
412   bool Verify() const;
414   DIScopeRef getContext() const { return getFieldAs<DIScopeRef>(2); }
415   StringRef getName() const { return getHeaderField(1); }
416   unsigned getLineNumber() const {
417     return getHeaderFieldAs<unsigned>(2);
418   }
419   uint64_t getSizeInBits() const {
420     return getHeaderFieldAs<unsigned>(3);
421   }
422   uint64_t getAlignInBits() const {
423     return getHeaderFieldAs<unsigned>(4);
424   }
425   // FIXME: Offset is only used for DW_TAG_member nodes.  Making every type
426   // carry this is just plain insane.
427   uint64_t getOffsetInBits() const {
428     return getHeaderFieldAs<unsigned>(5);
429   }
430   unsigned getFlags() const { return getHeaderFieldAs<unsigned>(6); }
431   bool isPrivate() const {
432     return (getFlags() & FlagAccessibility) == FlagPrivate;
433   }
434   bool isProtected() const {
435     return (getFlags() & FlagAccessibility) == FlagProtected;
436   }
437   bool isPublic() const {
438     return (getFlags() & FlagAccessibility) == FlagPublic;
439   }
440   bool isForwardDecl() const { return (getFlags() & FlagFwdDecl) != 0; }
441   bool isAppleBlockExtension() const {
442     return (getFlags() & FlagAppleBlock) != 0;
443   }
444   bool isBlockByrefStruct() const {
445     return (getFlags() & FlagBlockByrefStruct) != 0;
446   }
447   bool isVirtual() const { return (getFlags() & FlagVirtual) != 0; }
448   bool isArtificial() const { return (getFlags() & FlagArtificial) != 0; }
449   bool isObjectPointer() const { return (getFlags() & FlagObjectPointer) != 0; }
450   bool isObjcClassComplete() const {
451     return (getFlags() & FlagObjcClassComplete) != 0;
452   }
453   bool isVector() const { return (getFlags() & FlagVector) != 0; }
454   bool isStaticMember() const { return (getFlags() & FlagStaticMember) != 0; }
455   bool isLValueReference() const {
456     return (getFlags() & FlagLValueReference) != 0;
457   }
458   bool isRValueReference() const {
459     return (getFlags() & FlagRValueReference) != 0;
460   }
461   bool isValid() const { return DbgNode && isType(); }
462 };
464 /// \brief A basic type, like 'int' or 'float'.
465 class DIBasicType : public DIType {
466 public:
467   explicit DIBasicType(const MDNode *N = nullptr) : DIType(N) {}
469   unsigned getEncoding() const { return getHeaderFieldAs<unsigned>(7); }
471   bool Verify() const;
472 };
474 /// \brief A simple derived type
475 ///
476 /// Like a const qualified type, a typedef, a pointer or reference, et cetera.
477 /// Or, a data member of a class/struct/union.
478 class DIDerivedType : public DIType {
479   friend class DIDescriptor;
480   void printInternal(raw_ostream &OS) const;
482 public:
483   explicit DIDerivedType(const MDNode *N = nullptr) : DIType(N) {}
485   DITypeRef getTypeDerivedFrom() const { return getFieldAs<DITypeRef>(3); }
487   /// \brief Return property node, if this ivar is associated with one.
488   MDNode *getObjCProperty() const;
490   DITypeRef getClassType() const {
491     assert(getTag() == dwarf::DW_TAG_ptr_to_member_type);
492     return getFieldAs<DITypeRef>(4);
493   }
495   Constant *getConstant() const {
496     assert((getTag() == dwarf::DW_TAG_member) && isStaticMember());
497     return getConstantField(4);
498   }
500   bool Verify() const;
501 };
503 /// \brief Types that refer to multiple other types.
504 ///
505 /// This descriptor holds a type that can refer to multiple other types, like a
506 /// function or struct.
507 ///
508 /// DICompositeType is derived from DIDerivedType because some
509 /// composite types (such as enums) can be derived from basic types
510 // FIXME: Make this derive from DIType directly & just store the
511 // base type in a single DIType field.
512 class DICompositeType : public DIDerivedType {
513   friend class DIBuilder;
514   friend class DIDescriptor;
515   void printInternal(raw_ostream &OS) const;
517   /// \brief Set the array of member DITypes.
518   void setArraysHelper(MDNode *Elements, MDNode *TParams);
520 public:
521   explicit DICompositeType(const MDNode *N = nullptr) : DIDerivedType(N) {}
523   DIArray getElements() const {
524     assert(!isSubroutineType() && "no elements for DISubroutineType");
525     return getFieldAs<DIArray>(4);
526   }
528 private:
529   template <typename T>
530   void setArrays(DITypedArray<T> Elements, DIArray TParams = DIArray()) {
531     assert((!TParams || DbgNode->getNumOperands() == 8) &&
532            "If you're setting the template parameters this should include a slot "
533            "for that!");
534     setArraysHelper(Elements, TParams);
535   }
537 public:
538   unsigned getRunTimeLang() const {
539     return getHeaderFieldAs<unsigned>(7);
540   }
541   DITypeRef getContainingType() const { return getFieldAs<DITypeRef>(5); }
543 private:
544   /// \brief Set the containing type.
545   void setContainingType(DICompositeType ContainingType);
547 public:
548   DIArray getTemplateParams() const { return getFieldAs<DIArray>(6); }
549   MDString *getIdentifier() const;
551   bool Verify() const;
552 };
554 class DISubroutineType : public DICompositeType {
555 public:
556   explicit DISubroutineType(const MDNode *N = nullptr) : DICompositeType(N) {}
557   DITypedArray<DITypeRef> getTypeArray() const {
558     return getFieldAs<DITypedArray<DITypeRef>>(4);
559   }
560 };
562 /// \brief This is a wrapper for a file.
563 class DIFile : public DIScope {
564   friend class DIDescriptor;
566 public:
567   explicit DIFile(const MDNode *N = nullptr) : DIScope(N) {}
569   /// \brief Retrieve the MDNode for the directory/file pair.
570   MDNode *getFileNode() const;
571   bool Verify() const;
572 };
574 /// \brief A wrapper for a compile unit.
575 class DICompileUnit : public DIScope {
576   friend class DIDescriptor;
577   void printInternal(raw_ostream &OS) const;
579 public:
580   explicit DICompileUnit(const MDNode *N = nullptr) : DIScope(N) {}
582   dwarf::SourceLanguage getLanguage() const {
583     return static_cast<dwarf::SourceLanguage>(getHeaderFieldAs<unsigned>(1));
584   }
585   StringRef getProducer() const { return getHeaderField(2); }
587   bool isOptimized() const { return getHeaderFieldAs<bool>(3) != 0; }
588   StringRef getFlags() const { return getHeaderField(4); }
589   unsigned getRunTimeVersion() const { return getHeaderFieldAs<unsigned>(5); }
591   DIArray getEnumTypes() const;
592   DIArray getRetainedTypes() const;
593   DIArray getSubprograms() const;
594   DIArray getGlobalVariables() const;
595   DIArray getImportedEntities() const;
597   void replaceSubprograms(DIArray Subprograms);
598   void replaceGlobalVariables(DIArray GlobalVariables);
600   StringRef getSplitDebugFilename() const { return getHeaderField(6); }
601   unsigned getEmissionKind() const { return getHeaderFieldAs<unsigned>(7); }
603   bool Verify() const;
604 };
606 /// \brief This is a wrapper for a subprogram (e.g. a function).
607 class DISubprogram : public DIScope {
608   friend class DIDescriptor;
609   void printInternal(raw_ostream &OS) const;
611 public:
612   explicit DISubprogram(const MDNode *N = nullptr) : DIScope(N) {}
614   StringRef getName() const { return getHeaderField(1); }
615   StringRef getDisplayName() const { return getHeaderField(2); }
616   StringRef getLinkageName() const { return getHeaderField(3); }
617   unsigned getLineNumber() const { return getHeaderFieldAs<unsigned>(4); }
619   /// \brief Check if this is local (like 'static' in C).
620   unsigned isLocalToUnit() const { return getHeaderFieldAs<unsigned>(5); }
621   unsigned isDefinition() const { return getHeaderFieldAs<unsigned>(6); }
623   unsigned getVirtuality() const { return getHeaderFieldAs<unsigned>(7); }
624   unsigned getVirtualIndex() const { return getHeaderFieldAs<unsigned>(8); }
626   unsigned getFlags() const { return getHeaderFieldAs<unsigned>(9); }
628   unsigned isOptimized() const { return getHeaderFieldAs<bool>(10); }
630   /// \brief Get the beginning of the scope of the function (not the name).
631   unsigned getScopeLineNumber() const { return getHeaderFieldAs<unsigned>(11); }
633   DIScopeRef getContext() const { return getFieldAs<DIScopeRef>(2); }
634   DISubroutineType getType() const { return getFieldAs<DISubroutineType>(3); }
636   DITypeRef getContainingType() const { return getFieldAs<DITypeRef>(4); }
638   bool Verify() const;
640   /// \brief Check if this provides debugging information for the function F.
641   bool describes(const Function *F);
643   Function *getFunction() const { return getFunctionField(5); }
644   void replaceFunction(Function *F) { replaceFunctionField(5, F); }
645   DIArray getTemplateParams() const { return getFieldAs<DIArray>(6); }
646   DISubprogram getFunctionDeclaration() const {
647     return getFieldAs<DISubprogram>(7);
648   }
649   MDNode *getVariablesNodes() const;
650   DIArray getVariables() const;
652   unsigned isArtificial() const { return (getFlags() & FlagArtificial) != 0; }
653   /// \brief Check for the "private" access specifier.
654   bool isPrivate() const {
655     return (getFlags() & FlagAccessibility) == FlagPrivate;
656   }
657   /// \brief Check for the "protected" access specifier.
658   bool isProtected() const {
659     return (getFlags() & FlagAccessibility) == FlagProtected;
660   }
661   /// \brief Check for the "public" access specifier.
662   bool isPublic() const {
663     return (getFlags() & FlagAccessibility) == FlagPublic;
664   }
665   /// \brief Check for "explicit".
666   bool isExplicit() const { return (getFlags() & FlagExplicit) != 0; }
667   /// \brief Check if this is prototyped.
668   bool isPrototyped() const { return (getFlags() & FlagPrototyped) != 0; }
670   /// \brief Check if this is reference-qualified.
671   ///
672   /// Return true if this subprogram is a C++11 reference-qualified non-static
673   /// member function (void foo() &).
674   unsigned isLValueReference() const {
675     return (getFlags() & FlagLValueReference) != 0;
676   }
678   /// \brief Check if this is rvalue-reference-qualified.
679   ///
680   /// Return true if this subprogram is a C++11 rvalue-reference-qualified
681   /// non-static member function (void foo() &&).
682   unsigned isRValueReference() const {
683     return (getFlags() & FlagRValueReference) != 0;
684   }
686 };
688 /// \brief This is a wrapper for a lexical block.
689 class DILexicalBlock : public DIScope {
690 public:
691   explicit DILexicalBlock(const MDNode *N = nullptr) : DIScope(N) {}
692   DIScope getContext() const { return getFieldAs<DIScope>(2); }
693   unsigned getLineNumber() const {
694     return getHeaderFieldAs<unsigned>(1);
695   }
696   unsigned getColumnNumber() const {
697     return getHeaderFieldAs<unsigned>(2);
698   }
699   bool Verify() const;
700 };
702 /// \brief This is a wrapper for a lexical block with a filename change.
703 class DILexicalBlockFile : public DIScope {
704 public:
705   explicit DILexicalBlockFile(const MDNode *N = nullptr) : DIScope(N) {}
706   DIScope getContext() const {
707     if (getScope().isSubprogram())
708       return getScope();
709     return getScope().getContext();
710   }
711   unsigned getLineNumber() const { return getScope().getLineNumber(); }
712   unsigned getColumnNumber() const { return getScope().getColumnNumber(); }
713   DILexicalBlock getScope() const { return getFieldAs<DILexicalBlock>(2); }
714   unsigned getDiscriminator() const { return getHeaderFieldAs<unsigned>(1); }
715   bool Verify() const;
716 };
718 /// \brief A wrapper for a C++ style name space.
719 class DINameSpace : public DIScope {
720   friend class DIDescriptor;
721   void printInternal(raw_ostream &OS) const;
723 public:
724   explicit DINameSpace(const MDNode *N = nullptr) : DIScope(N) {}
725   StringRef getName() const { return getHeaderField(1); }
726   unsigned getLineNumber() const { return getHeaderFieldAs<unsigned>(2); }
727   DIScope getContext() const { return getFieldAs<DIScope>(2); }
728   bool Verify() const;
729 };
731 /// \brief This is a wrapper for template type parameter.
732 class DITemplateTypeParameter : public DIDescriptor {
733 public:
734   explicit DITemplateTypeParameter(const MDNode *N = nullptr)
735     : DIDescriptor(N) {}
737   StringRef getName() const { return getHeaderField(1); }
738   unsigned getLineNumber() const { return getHeaderFieldAs<unsigned>(2); }
739   unsigned getColumnNumber() const { return getHeaderFieldAs<unsigned>(3); }
741   DIScopeRef getContext() const { return getFieldAs<DIScopeRef>(1); }
742   DITypeRef getType() const { return getFieldAs<DITypeRef>(2); }
743   StringRef getFilename() const { return getFieldAs<DIFile>(3).getFilename(); }
744   StringRef getDirectory() const {
745     return getFieldAs<DIFile>(3).getDirectory();
746   }
747   bool Verify() const;
748 };
750 /// \brief This is a wrapper for template value parameter.
751 class DITemplateValueParameter : public DIDescriptor {
752 public:
753   explicit DITemplateValueParameter(const MDNode *N = nullptr)
754     : DIDescriptor(N) {}
756   StringRef getName() const { return getHeaderField(1); }
757   unsigned getLineNumber() const { return getHeaderFieldAs<unsigned>(2); }
758   unsigned getColumnNumber() const { return getHeaderFieldAs<unsigned>(3); }
760   DIScopeRef getContext() const { return getFieldAs<DIScopeRef>(1); }
761   DITypeRef getType() const { return getFieldAs<DITypeRef>(2); }
762   Metadata *getValue() const;
763   StringRef getFilename() const { return getFieldAs<DIFile>(4).getFilename(); }
764   StringRef getDirectory() const {
765     return getFieldAs<DIFile>(4).getDirectory();
766   }
767   bool Verify() const;
768 };
770 /// \brief This is a wrapper for a global variable.
771 class DIGlobalVariable : public DIDescriptor {
772   friend class DIDescriptor;
773   void printInternal(raw_ostream &OS) const;
775 public:
776   explicit DIGlobalVariable(const MDNode *N = nullptr) : DIDescriptor(N) {}
778   StringRef getName() const { return getHeaderField(1); }
779   StringRef getDisplayName() const { return getHeaderField(2); }
780   StringRef getLinkageName() const { return getHeaderField(3); }
781   unsigned getLineNumber() const { return getHeaderFieldAs<unsigned>(4); }
782   unsigned isLocalToUnit() const { return getHeaderFieldAs<bool>(5); }
783   unsigned isDefinition() const { return getHeaderFieldAs<bool>(6); }
785   DIScope getContext() const { return getFieldAs<DIScope>(1); }
786   StringRef getFilename() const { return getFieldAs<DIFile>(2).getFilename(); }
787   StringRef getDirectory() const {
788     return getFieldAs<DIFile>(2).getDirectory();
789   }
790   DITypeRef getType() const { return getFieldAs<DITypeRef>(3); }
792   GlobalVariable *getGlobal() const { return getGlobalVariableField(4); }
793   Constant *getConstant() const { return getConstantField(4); }
794   DIDerivedType getStaticDataMemberDeclaration() const {
795     return getFieldAs<DIDerivedType>(5);
796   }
798   bool Verify() const;
799 };
801 /// \brief This is a wrapper for a variable (e.g. parameter, local, global etc).
802 class DIVariable : public DIDescriptor {
803   friend class DIDescriptor;
804   void printInternal(raw_ostream &OS) const;
806 public:
807   explicit DIVariable(const MDNode *N = nullptr) : DIDescriptor(N) {}
809   StringRef getName() const { return getHeaderField(1); }
810   unsigned getLineNumber() const {
811     // FIXME: Line number and arg number shouldn't be merged together like this.
812     return (getHeaderFieldAs<unsigned>(2) << 8) >> 8;
813   }
814   unsigned getArgNumber() const { return getHeaderFieldAs<unsigned>(2) >> 24; }
816   DIScope getContext() const { return getFieldAs<DIScope>(1); }
817   DIFile getFile() const { return getFieldAs<DIFile>(2); }
818   DITypeRef getType() const { return getFieldAs<DITypeRef>(3); }
820   /// \brief Return true if this variable is marked as "artificial".
821   bool isArtificial() const {
822     return (getHeaderFieldAs<unsigned>(3) & FlagArtificial) != 0;
823   }
825   bool isObjectPointer() const {
826     return (getHeaderFieldAs<unsigned>(3) & FlagObjectPointer) != 0;
827   }
829   /// \brief If this variable is inlined then return inline location.
830   MDNode *getInlinedAt() const;
832   bool Verify() const;
834   /// \brief Check if this is a "__block" variable (Apple Blocks).
835   bool isBlockByrefVariable(const DITypeIdentifierMap &Map) const {
836     return (getType().resolve(Map)).isBlockByrefStruct();
837   }
839   /// \brief Check if this is an inlined function argument.
840   bool isInlinedFnArgument(const Function *CurFn);
842   /// \brief Return the size reported by the variable's type.
843   unsigned getSizeInBits(const DITypeIdentifierMap &Map);
845   void printExtendedName(raw_ostream &OS) const;
846 };
848 class DIExpressionIterator;
850 /// \brief A complex location expression.
851 class DIExpression : public DIDescriptor {
852   friend class DIDescriptor;
853   void printInternal(raw_ostream &OS) const;
855 public:
856   explicit DIExpression(const MDNode *N = nullptr) : DIDescriptor(N) {}
858   bool Verify() const;
860   /// \brief Return the number of elements in the complex expression.
861   unsigned getNumElements() const {
862     if (!DbgNode)
863       return 0;
864     unsigned N = getNumHeaderFields();
865     assert(N > 0 && "missing tag");
866     return N - 1;
867   }
869   /// \brief return the Idx'th complex address element.
870   uint64_t getElement(unsigned Idx) const;
872   /// \brief Return whether this is a piece of an aggregate variable.
873   bool isVariablePiece() const;
874   /// \brief Return the offset of this piece in bytes.
875   uint64_t getPieceOffset() const;
876   /// \brief Return the size of this piece in bytes.
877   uint64_t getPieceSize() const;
879   DIExpressionIterator begin() const;
880   DIExpressionIterator end() const;
881 };
883 /// \brief An iterator for DIExpression elments.
884 class DIExpressionIterator
885     : public std::iterator<std::forward_iterator_tag, StringRef, unsigned,
886                            const uint64_t *, uint64_t> {
887   DIHeaderFieldIterator I;
888   DIExpressionIterator(DIHeaderFieldIterator I) : I(I) {}
889 public:
890   DIExpressionIterator() {}
891   DIExpressionIterator(const DIExpression Expr)
892     : I(Expr.getHeader()) { ++I; }
893   uint64_t operator*() const { return I.getNumber<uint64_t>(); }
894   DIExpressionIterator &operator++() {
895     increment();
896     return *this;
897   }
898   DIExpressionIterator operator++(int) {
899     DIExpressionIterator X(*this);
900     increment();
901     return X;
902   }
903   bool operator==(const DIExpressionIterator &X) const {
904     return I == X.I;
905   }
906   bool operator!=(const DIExpressionIterator &X) const {
907     return !(*this == X);
908   }
910   uint64_t getArg(unsigned N) const {
911     auto In = I;
912     std::advance(In, N);
913     return *DIExpressionIterator(In);
914   }
916   const DIHeaderFieldIterator& getBase() const { return I; }
918 private:
919   void increment() {
920     switch (**this) {
921     case dwarf::DW_OP_piece: std::advance(I, 3); break;
922     case dwarf::DW_OP_plus:  std::advance(I, 2); break;
923     case dwarf::DW_OP_deref: std::advance(I, 1); break;
924     default:
925       assert("unsupported operand");
926     }
927   }
928 };
931 /// \brief This object holds location information.
932 ///
933 /// This object is not associated with any DWARF tag.
934 class DILocation : public DIDescriptor {
935 public:
936   explicit DILocation(const MDNode *N) : DIDescriptor(N) {}
938   unsigned getLineNumber() const {
939     if (auto *L = dyn_cast_or_null<MDLocation>(DbgNode))
940       return L->getLine();
941     return 0;
942   }
943   unsigned getColumnNumber() const {
944     if (auto *L = dyn_cast_or_null<MDLocation>(DbgNode))
945       return L->getColumn();
946     return 0;
947   }
948   DIScope getScope() const {
949     if (auto *L = dyn_cast_or_null<MDLocation>(DbgNode))
950       return DIScope(dyn_cast_or_null<MDNode>(L->getScope()));
951     return DIScope(nullptr);
952   }
953   DILocation getOrigLocation() const {
954     if (auto *L = dyn_cast_or_null<MDLocation>(DbgNode))
955       return DILocation(dyn_cast_or_null<MDNode>(L->getInlinedAt()));
956     return DILocation(nullptr);
957   }
958   StringRef getFilename() const { return getScope().getFilename(); }
959   StringRef getDirectory() const { return getScope().getDirectory(); }
960   bool Verify() const;
961   bool atSameLineAs(const DILocation &Other) const {
962     return (getLineNumber() == Other.getLineNumber() &&
963             getFilename() == Other.getFilename());
964   }
965   /// \brief Get the DWAF discriminator.
966   ///
967   /// DWARF discriminators are used to distinguish identical file locations for
968   /// instructions that are on different basic blocks. If two instructions are
969   /// inside the same lexical block and are in different basic blocks, we
970   /// create a new lexical block with identical location as the original but
971   /// with a different discriminator value
972   /// (lib/Transforms/Util/AddDiscriminators.cpp for details).
973   unsigned getDiscriminator() const {
974     // Since discriminators are associated with lexical blocks, make
975     // sure this location is a lexical block before retrieving its
976     // value.
977     return getScope().isLexicalBlockFile()
978                ? DILexicalBlockFile(
979                      cast<MDNode>(cast<MDLocation>(DbgNode)->getScope()))
980                      .getDiscriminator()
981                : 0;
982   }
984   /// \brief Generate a new discriminator value for this location.
985   unsigned computeNewDiscriminator(LLVMContext &Ctx);
987   /// \brief Return a copy of this location with a different scope.
988   DILocation copyWithNewScope(LLVMContext &Ctx, DILexicalBlockFile NewScope);
989 };
991 class DIObjCProperty : public DIDescriptor {
992   friend class DIDescriptor;
993   void printInternal(raw_ostream &OS) const;
995 public:
996   explicit DIObjCProperty(const MDNode *N) : DIDescriptor(N) {}
998   StringRef getObjCPropertyName() const { return getHeaderField(1); }
999   DIFile getFile() const { return getFieldAs<DIFile>(1); }
1000   unsigned getLineNumber() const { return getHeaderFieldAs<unsigned>(2); }
1002   StringRef getObjCPropertyGetterName() const { return getHeaderField(3); }
1003   StringRef getObjCPropertySetterName() const { return getHeaderField(4); }
1004   unsigned getAttributes() const { return getHeaderFieldAs<unsigned>(5); }
1005   bool isReadOnlyObjCProperty() const {
1006     return (getAttributes() & dwarf::DW_APPLE_PROPERTY_readonly) != 0;
1007   }
1008   bool isReadWriteObjCProperty() const {
1009     return (getAttributes() & dwarf::DW_APPLE_PROPERTY_readwrite) != 0;
1010   }
1011   bool isAssignObjCProperty() const {
1012     return (getAttributes() & dwarf::DW_APPLE_PROPERTY_assign) != 0;
1013   }
1014   bool isRetainObjCProperty() const {
1015     return (getAttributes() & dwarf::DW_APPLE_PROPERTY_retain) != 0;
1016   }
1017   bool isCopyObjCProperty() const {
1018     return (getAttributes() & dwarf::DW_APPLE_PROPERTY_copy) != 0;
1019   }
1020   bool isNonAtomicObjCProperty() const {
1021     return (getAttributes() & dwarf::DW_APPLE_PROPERTY_nonatomic) != 0;
1022   }
1024   /// \brief Get the type.
1025   ///
1026   /// \note Objective-C doesn't have an ODR, so there is no benefit in storing
1027   /// the type as a DITypeRef here.
1028   DIType getType() const { return getFieldAs<DIType>(2); }
1030   bool Verify() const;
1031 };
1033 /// \brief An imported module (C++ using directive or similar).
1034 class DIImportedEntity : public DIDescriptor {
1035   friend class DIDescriptor;
1036   void printInternal(raw_ostream &OS) const;
1038 public:
1039   explicit DIImportedEntity(const MDNode *N) : DIDescriptor(N) {}
1040   DIScope getContext() const { return getFieldAs<DIScope>(1); }
1041   DIScopeRef getEntity() const { return getFieldAs<DIScopeRef>(2); }
1042   unsigned getLineNumber() const { return getHeaderFieldAs<unsigned>(1); }
1043   StringRef getName() const { return getHeaderField(2); }
1044   bool Verify() const;
1045 };
1047 /// \brief Find subprogram that is enclosing this scope.
1048 DISubprogram getDISubprogram(const MDNode *Scope);
1050 /// \brief Find debug info for a given function.
1051 /// \returns a valid DISubprogram, if found. Otherwise, it returns an empty
1052 /// DISubprogram.
1053 DISubprogram getDISubprogram(const Function *F);
1055 /// \brief Find underlying composite type.
1056 DICompositeType getDICompositeType(DIType T);
1058 /// \brief Create a new inlined variable based on current variable.
1059 ///
1060 /// @param DV            Current Variable.
1061 /// @param InlinedScope  Location at current variable is inlined.
1062 DIVariable createInlinedVariable(MDNode *DV, MDNode *InlinedScope,
1063                                  LLVMContext &VMContext);
1065 /// \brief Remove inlined scope from the variable.
1066 DIVariable cleanseInlinedVariable(MDNode *DV, LLVMContext &VMContext);
1068 /// \brief Generate map by visiting all retained types.
1069 DITypeIdentifierMap generateDITypeIdentifierMap(const NamedMDNode *CU_Nodes);
1071 /// \brief Strip debug info in the module if it exists.
1072 ///
1073 /// To do this, we remove all calls to the debugger intrinsics and any named
1074 /// metadata for debugging. We also remove debug locations for instructions.
1075 /// Return true if module is modified.
1076 bool StripDebugInfo(Module &M);
1078 /// \brief Return Debug Info Metadata Version by checking module flags.
1079 unsigned getDebugMetadataVersionFromModule(const Module &M);
1081 /// \brief Utility to find all debug info in a module.
1082 ///
1083 /// DebugInfoFinder tries to list all debug info MDNodes used in a module. To
1084 /// list debug info MDNodes used by an instruction, DebugInfoFinder uses
1085 /// processDeclare, processValue and processLocation to handle DbgDeclareInst,
1086 /// DbgValueInst and DbgLoc attached to instructions. processModule will go
1087 /// through all DICompileUnits in llvm.dbg.cu and list debug info MDNodes
1088 /// used by the CUs.
1089 class DebugInfoFinder {
1090 public:
1091   DebugInfoFinder() : TypeMapInitialized(false) {}
1093   /// \brief Process entire module and collect debug info anchors.
1094   void processModule(const Module &M);
1096   /// \brief Process DbgDeclareInst.
1097   void processDeclare(const Module &M, const DbgDeclareInst *DDI);
1098   /// \brief Process DbgValueInst.
1099   void processValue(const Module &M, const DbgValueInst *DVI);
1100   /// \brief Process DILocation.
1101   void processLocation(const Module &M, DILocation Loc);
1103   /// \brief Process DIExpression.
1104   void processExpression(DIExpression Expr);
1106   /// \brief Clear all lists.
1107   void reset();
1109 private:
1110   void InitializeTypeMap(const Module &M);
1112   void processType(DIType DT);
1113   void processSubprogram(DISubprogram SP);
1114   void processScope(DIScope Scope);
1115   bool addCompileUnit(DICompileUnit CU);
1116   bool addGlobalVariable(DIGlobalVariable DIG);
1117   bool addSubprogram(DISubprogram SP);
1118   bool addType(DIType DT);
1119   bool addScope(DIScope Scope);
1121 public:
1122   typedef SmallVectorImpl<DICompileUnit>::const_iterator compile_unit_iterator;
1123   typedef SmallVectorImpl<DISubprogram>::const_iterator subprogram_iterator;
1124   typedef SmallVectorImpl<DIGlobalVariable>::const_iterator global_variable_iterator;
1125   typedef SmallVectorImpl<DIType>::const_iterator type_iterator;
1126   typedef SmallVectorImpl<DIScope>::const_iterator scope_iterator;
1128   iterator_range<compile_unit_iterator> compile_units() const {
1129     return iterator_range<compile_unit_iterator>(CUs.begin(), CUs.end());
1130   }
1132   iterator_range<subprogram_iterator> subprograms() const {
1133     return iterator_range<subprogram_iterator>(SPs.begin(), SPs.end());
1134   }
1136   iterator_range<global_variable_iterator> global_variables() const {
1137     return iterator_range<global_variable_iterator>(GVs.begin(), GVs.end());
1138   }
1140   iterator_range<type_iterator> types() const {
1141     return iterator_range<type_iterator>(TYs.begin(), TYs.end());
1142   }
1144   iterator_range<scope_iterator> scopes() const {
1145     return iterator_range<scope_iterator>(Scopes.begin(), Scopes.end());
1146   }
1148   unsigned compile_unit_count() const { return CUs.size(); }
1149   unsigned global_variable_count() const { return GVs.size(); }
1150   unsigned subprogram_count() const { return SPs.size(); }
1151   unsigned type_count() const { return TYs.size(); }
1152   unsigned scope_count() const { return Scopes.size(); }
1154 private:
1155   SmallVector<DICompileUnit, 8> CUs;
1156   SmallVector<DISubprogram, 8> SPs;
1157   SmallVector<DIGlobalVariable, 8> GVs;
1158   SmallVector<DIType, 8> TYs;
1159   SmallVector<DIScope, 8> Scopes;
1160   SmallPtrSet<MDNode *, 64> NodesSeen;
1161   DITypeIdentifierMap TypeIdentifierMap;
1163   /// \brief Specify if TypeIdentifierMap is initialized.
1164   bool TypeMapInitialized;
1165 };
1167 DenseMap<const Function *, DISubprogram> makeSubprogramMap(const Module &M);
1169 } // end namespace llvm
1171 #endif