1 //===--- llvm/Analysis/DebugInfo.h - Debug Information Helpers --*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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
15 //===----------------------------------------------------------------------===//
17 #ifndef LLVM_ANALYSIS_DEBUGINFO_H
18 #define LLVM_ANALYSIS_DEBUGINFO_H
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/SmallPtrSet.h"
22 #include "llvm/ADT/StringRef.h"
23 #include "llvm/Support/Dwarf.h"
45 /// DIDescriptor - A thin wraper around MDNode to access encoded debug info.
46 /// This should not be stored in a container, because underly MDNode may
47 /// change in certain situations.
52 FlagProtected = 1 << 1,
54 FlagAppleBlock = 1 << 3,
55 FlagBlockByrefStruct = 1 << 4,
57 FlagArtificial = 1 << 6,
61 const MDNode *DbgNode;
63 StringRef getStringField(unsigned Elt) const;
64 unsigned getUnsignedField(unsigned Elt) const {
65 return (unsigned)getUInt64Field(Elt);
67 uint64_t getUInt64Field(unsigned Elt) const;
68 DIDescriptor getDescriptorField(unsigned Elt) const;
70 template <typename DescTy>
71 DescTy getFieldAs(unsigned Elt) const {
72 return DescTy(getDescriptorField(Elt));
75 GlobalVariable *getGlobalVariableField(unsigned Elt) const;
76 Constant *getConstantField(unsigned Elt) const;
77 Function *getFunctionField(unsigned Elt) const;
80 explicit DIDescriptor() : DbgNode(0) {}
81 explicit DIDescriptor(const MDNode *N) : DbgNode(N) {}
82 explicit DIDescriptor(const DIFile F);
83 explicit DIDescriptor(const DISubprogram F);
84 explicit DIDescriptor(const DILexicalBlock F);
85 explicit DIDescriptor(const DIVariable F);
86 explicit DIDescriptor(const DIType F);
88 bool Verify() const { return DbgNode != 0; }
90 operator MDNode *() const { return const_cast<MDNode*>(DbgNode); }
91 MDNode *operator ->() const { return const_cast<MDNode*>(DbgNode); }
93 unsigned getVersion() const {
94 return getUnsignedField(0) & LLVMDebugVersionMask;
97 unsigned getTag() const {
98 return getUnsignedField(0) & ~LLVMDebugVersionMask;
101 /// print - print descriptor.
102 void print(raw_ostream &OS) const;
104 /// dump - print descriptor to dbgs() with a newline.
107 bool isDerivedType() const;
108 bool isCompositeType() const;
109 bool isBasicType() const;
110 bool isVariable() const;
111 bool isSubprogram() const;
112 bool isGlobalVariable() const;
113 bool isScope() const;
115 bool isCompileUnit() const;
116 bool isNameSpace() const;
117 bool isLexicalBlock() const;
118 bool isSubrange() const;
119 bool isEnumerator() const;
121 bool isGlobal() const;
124 /// DISubrange - This is used to represent ranges, for array bounds.
125 class DISubrange : public DIDescriptor {
127 explicit DISubrange(const MDNode *N = 0) : DIDescriptor(N) {}
129 int64_t getLo() const { return (int64_t)getUInt64Field(1); }
130 int64_t getHi() const { return (int64_t)getUInt64Field(2); }
133 /// DIArray - This descriptor holds an array of descriptors.
134 class DIArray : public DIDescriptor {
136 explicit DIArray(const MDNode *N = 0)
139 unsigned getNumElements() const;
140 DIDescriptor getElement(unsigned Idx) const {
141 return getDescriptorField(Idx);
145 /// DIScope - A base class for various scopes.
146 class DIScope : public DIDescriptor {
148 explicit DIScope(const MDNode *N = 0) : DIDescriptor (N) {}
149 virtual ~DIScope() {}
151 StringRef getFilename() const;
152 StringRef getDirectory() const;
155 /// DICompileUnit - A wrapper for a compile unit.
156 class DICompileUnit : public DIScope {
158 explicit DICompileUnit(const MDNode *N = 0) : DIScope(N) {}
160 unsigned getLanguage() const { return getUnsignedField(2); }
161 StringRef getFilename() const { return getStringField(3); }
162 StringRef getDirectory() const { return getStringField(4); }
163 StringRef getProducer() const { return getStringField(5); }
165 /// isMain - Each input file is encoded as a separate compile unit in LLVM
166 /// debugging information output. However, many target specific tool chains
167 /// prefer to encode only one compile unit in an object file. In this
168 /// situation, the LLVM code generator will include debugging information
169 /// entities in the compile unit that is marked as main compile unit. The
170 /// code generator accepts maximum one main compile unit per module. If a
171 /// module does not contain any main compile unit then the code generator
172 /// will emit multiple compile units in the output object file.
174 bool isMain() const { return getUnsignedField(6) != 0; }
175 bool isOptimized() const { return getUnsignedField(7) != 0; }
176 StringRef getFlags() const { return getStringField(8); }
177 unsigned getRunTimeVersion() const { return getUnsignedField(9); }
179 /// Verify - Verify that a compile unit is well formed.
182 /// print - print compile unit.
183 void print(raw_ostream &OS) const;
185 /// dump - print compile unit to dbgs() with a newline.
189 /// DIFile - This is a wrapper for a file.
190 class DIFile : public DIScope {
192 explicit DIFile(const MDNode *N = 0) : DIScope(N) {
193 if (DbgNode && !isFile())
196 StringRef getFilename() const { return getStringField(1); }
197 StringRef getDirectory() const { return getStringField(2); }
198 DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
201 /// DIEnumerator - A wrapper for an enumerator (e.g. X and Y in 'enum {X,Y}').
202 /// FIXME: it seems strange that this doesn't have either a reference to the
203 /// type/precision or a file/line pair for location info.
204 class DIEnumerator : public DIDescriptor {
206 explicit DIEnumerator(const MDNode *N = 0) : DIDescriptor(N) {}
208 StringRef getName() const { return getStringField(1); }
209 uint64_t getEnumValue() const { return getUInt64Field(2); }
212 /// DIType - This is a wrapper for a type.
213 /// FIXME: Types should be factored much better so that CV qualifiers and
214 /// others do not require a huge and empty descriptor full of zeros.
215 class DIType : public DIScope {
218 // This ctor is used when the Tag has already been validated by a derived
220 DIType(const MDNode *N, bool, bool) : DIScope(N) {}
224 /// Verify - Verify that a type descriptor is well formed.
227 explicit DIType(const MDNode *N);
231 DIScope getContext() const { return getFieldAs<DIScope>(1); }
232 StringRef getName() const { return getStringField(2); }
233 DICompileUnit getCompileUnit() const{
234 if (getVersion() == llvm::LLVMDebugVersion7)
235 return getFieldAs<DICompileUnit>(3);
237 DIFile F = getFieldAs<DIFile>(3);
238 return F.getCompileUnit();
240 unsigned getLineNumber() const { return getUnsignedField(4); }
241 uint64_t getSizeInBits() const { return getUInt64Field(5); }
242 uint64_t getAlignInBits() const { return getUInt64Field(6); }
243 // FIXME: Offset is only used for DW_TAG_member nodes. Making every type
244 // carry this is just plain insane.
245 uint64_t getOffsetInBits() const { return getUInt64Field(7); }
246 unsigned getFlags() const { return getUnsignedField(8); }
247 bool isPrivate() const {
248 return (getFlags() & FlagPrivate) != 0;
250 bool isProtected() const {
251 return (getFlags() & FlagProtected) != 0;
253 bool isForwardDecl() const {
254 return (getFlags() & FlagFwdDecl) != 0;
256 // isAppleBlock - Return true if this is the Apple Blocks extension.
257 bool isAppleBlockExtension() const {
258 return (getFlags() & FlagAppleBlock) != 0;
260 bool isBlockByrefStruct() const {
261 return (getFlags() & FlagBlockByrefStruct) != 0;
263 bool isVirtual() const {
264 return (getFlags() & FlagVirtual) != 0;
266 bool isArtificial() const {
267 return (getFlags() & FlagArtificial) != 0;
269 bool isValid() const {
270 return DbgNode && (isBasicType() || isDerivedType() || isCompositeType());
272 StringRef getFilename() const { return getCompileUnit().getFilename();}
273 StringRef getDirectory() const { return getCompileUnit().getDirectory();}
275 /// replaceAllUsesWith - Replace all uses of debug info referenced by
277 void replaceAllUsesWith(DIDescriptor &D);
279 /// print - print type.
280 void print(raw_ostream &OS) const;
282 /// dump - print type to dbgs() with a newline.
286 /// DIBasicType - A basic type, like 'int' or 'float'.
287 class DIBasicType : public DIType {
289 explicit DIBasicType(const MDNode *N = 0) : DIType(N) {}
291 unsigned getEncoding() const { return getUnsignedField(9); }
293 /// Verify - Verify that a basic type descriptor is well formed.
296 /// print - print basic type.
297 void print(raw_ostream &OS) const;
299 /// dump - print basic type to dbgs() with a newline.
303 /// DIDerivedType - A simple derived type, like a const qualified type,
304 /// a typedef, a pointer or reference, etc.
305 class DIDerivedType : public DIType {
307 explicit DIDerivedType(const MDNode *N, bool, bool)
308 : DIType(N, true, true) {}
310 explicit DIDerivedType(const MDNode *N = 0)
311 : DIType(N, true, true) {}
313 DIType getTypeDerivedFrom() const { return getFieldAs<DIType>(9); }
315 /// getOriginalTypeSize - If this type is derived from a base type then
316 /// return base type size.
317 uint64_t getOriginalTypeSize() const;
319 /// Verify - Verify that a derived type descriptor is well formed.
322 /// print - print derived type.
323 void print(raw_ostream &OS) const;
325 /// dump - print derived type to dbgs() with a newline.
329 /// DICompositeType - This descriptor holds a type that can refer to multiple
330 /// other types, like a function or struct.
331 /// FIXME: Why is this a DIDerivedType??
332 class DICompositeType : public DIDerivedType {
334 explicit DICompositeType(const MDNode *N = 0)
335 : DIDerivedType(N, true, true) {
336 if (N && !isCompositeType())
340 DIArray getTypeArray() const { return getFieldAs<DIArray>(10); }
341 unsigned getRunTimeLang() const { return getUnsignedField(11); }
342 DICompositeType getContainingType() const {
343 return getFieldAs<DICompositeType>(12);
346 /// Verify - Verify that a composite type descriptor is well formed.
349 /// print - print composite type.
350 void print(raw_ostream &OS) const;
352 /// dump - print composite type to dbgs() with a newline.
356 /// DISubprogram - This is a wrapper for a subprogram (e.g. a function).
357 class DISubprogram : public DIScope {
359 explicit DISubprogram(const MDNode *N = 0) : DIScope(N) {}
361 DIScope getContext() const { return getFieldAs<DIScope>(2); }
362 StringRef getName() const { return getStringField(3); }
363 StringRef getDisplayName() const { return getStringField(4); }
364 StringRef getLinkageName() const { return getStringField(5); }
365 DICompileUnit getCompileUnit() const{
366 if (getVersion() == llvm::LLVMDebugVersion7)
367 return getFieldAs<DICompileUnit>(6);
369 DIFile F = getFieldAs<DIFile>(6);
370 return F.getCompileUnit();
372 unsigned getLineNumber() const { return getUnsignedField(7); }
373 DICompositeType getType() const { return getFieldAs<DICompositeType>(8); }
375 /// getReturnTypeName - Subprogram return types are encoded either as
376 /// DIType or as DICompositeType.
377 StringRef getReturnTypeName() const {
378 DICompositeType DCT(getFieldAs<DICompositeType>(8));
380 DIArray A = DCT.getTypeArray();
381 DIType T(A.getElement(0));
384 DIType T(getFieldAs<DIType>(8));
388 /// isLocalToUnit - Return true if this subprogram is local to the current
389 /// compile unit, like 'static' in C.
390 unsigned isLocalToUnit() const { return getUnsignedField(9); }
391 unsigned isDefinition() const { return getUnsignedField(10); }
393 unsigned getVirtuality() const { return getUnsignedField(11); }
394 unsigned getVirtualIndex() const { return getUnsignedField(12); }
396 DICompositeType getContainingType() const {
397 return getFieldAs<DICompositeType>(13);
399 unsigned isArtificial() const {
400 if (getVersion() <= llvm::LLVMDebugVersion8)
401 return getUnsignedField(14);
402 return (getUnsignedField(14) & FlagArtificial) != 0;
404 /// isPrivate - Return true if this subprogram has "private"
405 /// access specifier.
406 bool isPrivate() const {
407 if (getVersion() <= llvm::LLVMDebugVersion8)
409 return (getUnsignedField(14) & FlagPrivate) != 0;
411 /// isProtected - Return true if this subprogram has "protected"
412 /// access specifier.
413 bool isProtected() const {
414 if (getVersion() <= llvm::LLVMDebugVersion8)
416 return (getUnsignedField(14) & FlagProtected) != 0;
418 /// isExplicit - Return true if this subprogram is marked as explicit.
419 bool isExplicit() const {
420 if (getVersion() <= llvm::LLVMDebugVersion8)
422 return (getUnsignedField(14) & FlagExplicit) != 0;
425 unsigned isOptimized() const;
427 StringRef getFilename() const {
428 if (getVersion() == llvm::LLVMDebugVersion7)
429 return getCompileUnit().getFilename();
431 DIFile F = getFieldAs<DIFile>(6);
432 return F.getFilename();
435 StringRef getDirectory() const {
436 if (getVersion() == llvm::LLVMDebugVersion7)
437 return getCompileUnit().getFilename();
439 DIFile F = getFieldAs<DIFile>(6);
440 return F.getDirectory();
443 /// Verify - Verify that a subprogram descriptor is well formed.
446 /// print - print subprogram.
447 void print(raw_ostream &OS) const;
449 /// dump - print subprogram to dbgs() with a newline.
452 /// describes - Return true if this subprogram provides debugging
453 /// information for the function F.
454 bool describes(const Function *F);
456 Function *getFunction() const { return getFunctionField(16); }
459 /// DIGlobalVariable - This is a wrapper for a global variable.
460 class DIGlobalVariable : public DIDescriptor {
462 explicit DIGlobalVariable(const MDNode *N = 0) : DIDescriptor(N) {}
464 DIScope getContext() const { return getFieldAs<DIScope>(2); }
465 StringRef getName() const { return getStringField(3); }
466 StringRef getDisplayName() const { return getStringField(4); }
467 StringRef getLinkageName() const { return getStringField(5); }
468 DICompileUnit getCompileUnit() const{
469 if (getVersion() == llvm::LLVMDebugVersion7)
470 return getFieldAs<DICompileUnit>(6);
472 DIFile F = getFieldAs<DIFile>(6);
473 return F.getCompileUnit();
476 unsigned getLineNumber() const { return getUnsignedField(7); }
477 DIType getType() const { return getFieldAs<DIType>(8); }
478 unsigned isLocalToUnit() const { return getUnsignedField(9); }
479 unsigned isDefinition() const { return getUnsignedField(10); }
481 GlobalVariable *getGlobal() const { return getGlobalVariableField(11); }
482 Constant *getConstant() const { return getConstantField(11); }
484 /// Verify - Verify that a global variable descriptor is well formed.
487 /// print - print global variable.
488 void print(raw_ostream &OS) const;
490 /// dump - print global variable to dbgs() with a newline.
494 /// DIVariable - This is a wrapper for a variable (e.g. parameter, local,
496 class DIVariable : public DIDescriptor {
498 explicit DIVariable(const MDNode *N = 0)
501 DIScope getContext() const { return getFieldAs<DIScope>(1); }
502 StringRef getName() const { return getStringField(2); }
503 DICompileUnit getCompileUnit() const{
504 if (getVersion() == llvm::LLVMDebugVersion7)
505 return getFieldAs<DICompileUnit>(3);
507 DIFile F = getFieldAs<DIFile>(3);
508 return F.getCompileUnit();
510 unsigned getLineNumber() const { return getUnsignedField(4); }
511 DIType getType() const { return getFieldAs<DIType>(5); }
513 /// isArtificial - Return true if this variable is marked as "artificial".
514 bool isArtificial() const {
515 if (getVersion() <= llvm::LLVMDebugVersion8)
517 return (getUnsignedField(6) & FlagArtificial) != 0;
521 /// Verify - Verify that a variable descriptor is well formed.
524 /// HasComplexAddr - Return true if the variable has a complex address.
525 bool hasComplexAddress() const {
526 return getNumAddrElements() > 0;
529 unsigned getNumAddrElements() const;
531 uint64_t getAddrElement(unsigned Idx) const {
532 return getUInt64Field(Idx+6);
535 /// isBlockByrefVariable - Return true if the variable was declared as
536 /// a "__block" variable (Apple Blocks).
537 bool isBlockByrefVariable() const {
538 return getType().isBlockByrefStruct();
541 /// isInlinedFnArgument - Return trule if this variable provides debugging
542 /// information for an inlined function arguments.
543 bool isInlinedFnArgument(const Function *CurFn);
545 /// print - print variable.
546 void print(raw_ostream &OS) const;
548 /// dump - print variable to dbgs() with a newline.
552 /// DILexicalBlock - This is a wrapper for a lexical block.
553 class DILexicalBlock : public DIScope {
555 explicit DILexicalBlock(const MDNode *N = 0) : DIScope(N) {}
556 DIScope getContext() const { return getFieldAs<DIScope>(1); }
557 unsigned getLineNumber() const { return getUnsignedField(2); }
558 unsigned getColumnNumber() const { return getUnsignedField(3); }
559 StringRef getDirectory() const {
560 DIFile F = getFieldAs<DIFile>(4);
561 StringRef dir = F.getDirectory();
562 return !dir.empty() ? dir : getContext().getDirectory();
564 StringRef getFilename() const {
565 DIFile F = getFieldAs<DIFile>(4);
566 StringRef filename = F.getFilename();
567 return !filename.empty() ? filename : getContext().getFilename();
571 /// DINameSpace - A wrapper for a C++ style name space.
572 class DINameSpace : public DIScope {
574 explicit DINameSpace(const MDNode *N = 0) : DIScope(N) {}
575 DIScope getContext() const { return getFieldAs<DIScope>(1); }
576 StringRef getName() const { return getStringField(2); }
577 StringRef getDirectory() const { return getContext().getDirectory(); }
578 StringRef getFilename() const { return getContext().getFilename(); }
579 DICompileUnit getCompileUnit() const{
580 if (getVersion() == llvm::LLVMDebugVersion7)
581 return getFieldAs<DICompileUnit>(3);
583 DIFile F = getFieldAs<DIFile>(3);
584 return F.getCompileUnit();
586 unsigned getLineNumber() const { return getUnsignedField(4); }
590 /// DILocation - This object holds location information. This object
591 /// is not associated with any DWARF tag.
592 class DILocation : public DIDescriptor {
594 explicit DILocation(const MDNode *N) : DIDescriptor(N) { }
596 unsigned getLineNumber() const { return getUnsignedField(0); }
597 unsigned getColumnNumber() const { return getUnsignedField(1); }
598 DIScope getScope() const { return getFieldAs<DIScope>(2); }
599 DILocation getOrigLocation() const { return getFieldAs<DILocation>(3); }
600 StringRef getFilename() const { return getScope().getFilename(); }
601 StringRef getDirectory() const { return getScope().getDirectory(); }
605 /// DIFactory - This object assists with the construction of the various
609 LLVMContext& VMContext;
611 Function *DeclareFn; // llvm.dbg.declare
612 Function *ValueFn; // llvm.dbg.value
614 DIFactory(const DIFactory &); // DO NOT IMPLEMENT
615 void operator=(const DIFactory&); // DO NOT IMPLEMENT
617 enum ComplexAddrKind { OpPlus=1, OpDeref };
619 explicit DIFactory(Module &m);
621 /// GetOrCreateArray - Create an descriptor for an array of descriptors.
622 /// This implicitly uniques the arrays created.
623 DIArray GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys);
625 /// GetOrCreateSubrange - Create a descriptor for a value range. This
626 /// implicitly uniques the values returned.
627 DISubrange GetOrCreateSubrange(int64_t Lo, int64_t Hi);
629 /// CreateCompileUnit - Create a new descriptor for the specified compile
631 DICompileUnit CreateCompileUnit(unsigned LangID,
636 bool isOptimized = false,
637 StringRef Flags = "",
638 unsigned RunTimeVer = 0);
640 /// CreateFile - Create a new descriptor for the specified file.
641 DIFile CreateFile(StringRef Filename, StringRef Directory,
644 /// CreateEnumerator - Create a single enumerator value.
645 DIEnumerator CreateEnumerator(StringRef Name, uint64_t Val);
647 /// CreateBasicType - Create a basic type like int, float, etc.
648 DIBasicType CreateBasicType(DIDescriptor Context, StringRef Name,
649 DIFile F, unsigned LineNumber,
650 uint64_t SizeInBits, uint64_t AlignInBits,
651 uint64_t OffsetInBits, unsigned Flags,
654 /// CreateBasicType - Create a basic type like int, float, etc.
655 DIBasicType CreateBasicTypeEx(DIDescriptor Context, StringRef Name,
656 DIFile F, unsigned LineNumber,
657 Constant *SizeInBits, Constant *AlignInBits,
658 Constant *OffsetInBits, unsigned Flags,
661 /// CreateDerivedType - Create a derived type like const qualified type,
662 /// pointer, typedef, etc.
663 DIDerivedType CreateDerivedType(unsigned Tag, DIDescriptor Context,
667 uint64_t SizeInBits, uint64_t AlignInBits,
668 uint64_t OffsetInBits, unsigned Flags,
671 /// CreateDerivedType - Create a derived type like const qualified type,
672 /// pointer, typedef, etc.
673 DIDerivedType CreateDerivedTypeEx(unsigned Tag, DIDescriptor Context,
677 Constant *SizeInBits,
678 Constant *AlignInBits,
679 Constant *OffsetInBits, unsigned Flags,
682 /// CreateCompositeType - Create a composite type like array, struct, etc.
683 DICompositeType CreateCompositeType(unsigned Tag, DIDescriptor Context,
688 uint64_t AlignInBits,
689 uint64_t OffsetInBits, unsigned Flags,
692 unsigned RunTimeLang = 0,
693 MDNode *ContainingType = 0);
695 /// CreateTemporaryType - Create a temporary forward-declared type.
696 DIType CreateTemporaryType();
698 /// CreateArtificialType - Create a new DIType with "artificial" flag set.
699 DIType CreateArtificialType(DIType Ty);
701 /// CreateCompositeType - Create a composite type like array, struct, etc.
702 DICompositeType CreateCompositeTypeEx(unsigned Tag, DIDescriptor Context,
706 Constant *SizeInBits,
707 Constant *AlignInBits,
708 Constant *OffsetInBits,
712 unsigned RunTimeLang = 0,
713 MDNode *ContainingType = 0);
715 /// CreateSubprogram - Create a new descriptor for the specified subprogram.
716 /// See comments in DISubprogram for descriptions of these fields.
717 DISubprogram CreateSubprogram(DIDescriptor Context, StringRef Name,
718 StringRef DisplayName,
719 StringRef LinkageName,
720 DIFile F, unsigned LineNo,
721 DIType Ty, bool isLocalToUnit,
727 bool isOptimized = false,
730 /// CreateSubprogramDefinition - Create new subprogram descriptor for the
731 /// given declaration.
732 DISubprogram CreateSubprogramDefinition(DISubprogram &SPDeclaration);
734 /// CreateGlobalVariable - Create a new descriptor for the specified global.
736 CreateGlobalVariable(DIDescriptor Context, StringRef Name,
737 StringRef DisplayName,
738 StringRef LinkageName,
740 unsigned LineNo, DIType Ty, bool isLocalToUnit,
741 bool isDefinition, llvm::GlobalVariable *GV);
743 /// CreateGlobalVariable - Create a new descriptor for the specified constant.
745 CreateGlobalVariable(DIDescriptor Context, StringRef Name,
746 StringRef DisplayName,
747 StringRef LinkageName,
749 unsigned LineNo, DIType Ty, bool isLocalToUnit,
750 bool isDefinition, llvm::Constant *C);
752 /// CreateVariable - Create a new descriptor for the specified variable.
753 DIVariable CreateVariable(unsigned Tag, DIDescriptor Context,
755 DIFile F, unsigned LineNo,
756 DIType Ty, bool AlwaysPreserve = false,
759 /// CreateComplexVariable - Create a new descriptor for the specified
760 /// variable which has a complex address expression for its address.
761 DIVariable CreateComplexVariable(unsigned Tag, DIDescriptor Context,
762 StringRef Name, DIFile F, unsigned LineNo,
763 DIType Ty, Value *const *Addr,
766 /// CreateLexicalBlock - This creates a descriptor for a lexical block
767 /// with the specified parent context.
768 DILexicalBlock CreateLexicalBlock(DIDescriptor Context, DIFile F,
769 unsigned Line = 0, unsigned Col = 0);
771 /// CreateNameSpace - This creates new descriptor for a namespace
772 /// with the specified parent context.
773 DINameSpace CreateNameSpace(DIDescriptor Context, StringRef Name,
774 DIFile F, unsigned LineNo);
776 /// CreateLocation - Creates a debug info location.
777 DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
778 DIScope S, DILocation OrigLoc);
780 /// CreateLocation - Creates a debug info location.
781 DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
782 DIScope S, MDNode *OrigLoc = 0);
784 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
785 Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
786 BasicBlock *InsertAtEnd);
788 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
789 Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
790 Instruction *InsertBefore);
792 /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
793 Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
794 DIVariable D, BasicBlock *InsertAtEnd);
796 /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
797 Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
798 DIVariable D, Instruction *InsertBefore);
800 // RecordType - Record DIType in a module such that it is not lost even if
801 // it is not referenced through debug info anchors.
802 void RecordType(DIType T);
805 Constant *GetTagConstant(unsigned TAG);
808 bool getLocationInfo(const Value *V, std::string &DisplayName,
809 std::string &Type, unsigned &LineNo, std::string &File,
812 /// getDISubprogram - Find subprogram that is enclosing this scope.
813 DISubprogram getDISubprogram(const MDNode *Scope);
815 /// getDICompositeType - Find underlying composite type.
816 DICompositeType getDICompositeType(DIType T);
818 class DebugInfoFinder {
820 /// processModule - Process entire module and collect debug info
822 void processModule(Module &M);
825 /// processType - Process DIType.
826 void processType(DIType DT);
828 /// processLexicalBlock - Process DILexicalBlock.
829 void processLexicalBlock(DILexicalBlock LB);
831 /// processSubprogram - Process DISubprogram.
832 void processSubprogram(DISubprogram SP);
834 /// processDeclare - Process DbgDeclareInst.
835 void processDeclare(DbgDeclareInst *DDI);
837 /// processLocation - Process DILocation.
838 void processLocation(DILocation Loc);
840 /// addCompileUnit - Add compile unit into CUs.
841 bool addCompileUnit(DICompileUnit CU);
843 /// addGlobalVariable - Add global variable into GVs.
844 bool addGlobalVariable(DIGlobalVariable DIG);
846 // addSubprogram - Add subprgoram into SPs.
847 bool addSubprogram(DISubprogram SP);
849 /// addType - Add type into Tys.
850 bool addType(DIType DT);
853 typedef SmallVector<MDNode *, 8>::const_iterator iterator;
854 iterator compile_unit_begin() const { return CUs.begin(); }
855 iterator compile_unit_end() const { return CUs.end(); }
856 iterator subprogram_begin() const { return SPs.begin(); }
857 iterator subprogram_end() const { return SPs.end(); }
858 iterator global_variable_begin() const { return GVs.begin(); }
859 iterator global_variable_end() const { return GVs.end(); }
860 iterator type_begin() const { return TYs.begin(); }
861 iterator type_end() const { return TYs.end(); }
863 unsigned compile_unit_count() const { return CUs.size(); }
864 unsigned global_variable_count() const { return GVs.size(); }
865 unsigned subprogram_count() const { return SPs.size(); }
866 unsigned type_count() const { return TYs.size(); }
869 SmallVector<MDNode *, 8> CUs; // Compile Units
870 SmallVector<MDNode *, 8> SPs; // Subprograms
871 SmallVector<MDNode *, 8> GVs; // Global Variables;
872 SmallVector<MDNode *, 8> TYs; // Types
873 SmallPtrSet<MDNode *, 64> NodesSeen;
875 } // end namespace llvm