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,
58 FlagExplicit = 1 << 7,
59 FlagPrototyped = 1 << 8
62 const MDNode *DbgNode;
64 StringRef getStringField(unsigned Elt) const;
65 unsigned getUnsignedField(unsigned Elt) const {
66 return (unsigned)getUInt64Field(Elt);
68 uint64_t getUInt64Field(unsigned Elt) const;
69 DIDescriptor getDescriptorField(unsigned Elt) const;
71 template <typename DescTy>
72 DescTy getFieldAs(unsigned Elt) const {
73 return DescTy(getDescriptorField(Elt));
76 GlobalVariable *getGlobalVariableField(unsigned Elt) const;
77 Constant *getConstantField(unsigned Elt) const;
78 Function *getFunctionField(unsigned Elt) const;
81 explicit DIDescriptor() : DbgNode(0) {}
82 explicit DIDescriptor(const MDNode *N) : DbgNode(N) {}
83 explicit DIDescriptor(const DIFile F);
84 explicit DIDescriptor(const DISubprogram F);
85 explicit DIDescriptor(const DILexicalBlock F);
86 explicit DIDescriptor(const DIVariable F);
87 explicit DIDescriptor(const DIType F);
89 bool Verify() const { return DbgNode != 0; }
91 operator MDNode *() const { return const_cast<MDNode*>(DbgNode); }
92 MDNode *operator ->() const { return const_cast<MDNode*>(DbgNode); }
94 unsigned getVersion() const {
95 return getUnsignedField(0) & LLVMDebugVersionMask;
98 unsigned getTag() const {
99 return getUnsignedField(0) & ~LLVMDebugVersionMask;
102 /// print - print descriptor.
103 void print(raw_ostream &OS) const;
105 /// dump - print descriptor to dbgs() with a newline.
108 bool isDerivedType() const;
109 bool isCompositeType() const;
110 bool isBasicType() const;
111 bool isVariable() const;
112 bool isSubprogram() const;
113 bool isGlobalVariable() const;
114 bool isScope() const;
116 bool isCompileUnit() const;
117 bool isNameSpace() const;
118 bool isLexicalBlock() const;
119 bool isSubrange() const;
120 bool isEnumerator() const;
122 bool isGlobal() const;
123 bool isUnspecifiedParameter() const;
126 /// DISubrange - This is used to represent ranges, for array bounds.
127 class DISubrange : public DIDescriptor {
129 explicit DISubrange(const MDNode *N = 0) : DIDescriptor(N) {}
131 int64_t getLo() const { return (int64_t)getUInt64Field(1); }
132 int64_t getHi() const { return (int64_t)getUInt64Field(2); }
135 /// DIArray - This descriptor holds an array of descriptors.
136 class DIArray : public DIDescriptor {
138 explicit DIArray(const MDNode *N = 0)
141 unsigned getNumElements() const;
142 DIDescriptor getElement(unsigned Idx) const {
143 return getDescriptorField(Idx);
147 /// DIScope - A base class for various scopes.
148 class DIScope : public DIDescriptor {
150 explicit DIScope(const MDNode *N = 0) : DIDescriptor (N) {}
151 virtual ~DIScope() {}
153 StringRef getFilename() const;
154 StringRef getDirectory() const;
157 /// DICompileUnit - A wrapper for a compile unit.
158 class DICompileUnit : public DIScope {
160 explicit DICompileUnit(const MDNode *N = 0) : DIScope(N) {}
162 unsigned getLanguage() const { return getUnsignedField(2); }
163 StringRef getFilename() const { return getStringField(3); }
164 StringRef getDirectory() const { return getStringField(4); }
165 StringRef getProducer() const { return getStringField(5); }
167 /// isMain - Each input file is encoded as a separate compile unit in LLVM
168 /// debugging information output. However, many target specific tool chains
169 /// prefer to encode only one compile unit in an object file. In this
170 /// situation, the LLVM code generator will include debugging information
171 /// entities in the compile unit that is marked as main compile unit. The
172 /// code generator accepts maximum one main compile unit per module. If a
173 /// module does not contain any main compile unit then the code generator
174 /// will emit multiple compile units in the output object file.
176 bool isMain() const { return getUnsignedField(6) != 0; }
177 bool isOptimized() const { return getUnsignedField(7) != 0; }
178 StringRef getFlags() const { return getStringField(8); }
179 unsigned getRunTimeVersion() const { return getUnsignedField(9); }
181 /// Verify - Verify that a compile unit is well formed.
184 /// print - print compile unit.
185 void print(raw_ostream &OS) const;
187 /// dump - print compile unit to dbgs() with a newline.
191 /// DIFile - This is a wrapper for a file.
192 class DIFile : public DIScope {
194 explicit DIFile(const MDNode *N = 0) : DIScope(N) {
195 if (DbgNode && !isFile())
198 StringRef getFilename() const { return getStringField(1); }
199 StringRef getDirectory() const { return getStringField(2); }
200 DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
203 /// DIEnumerator - A wrapper for an enumerator (e.g. X and Y in 'enum {X,Y}').
204 /// FIXME: it seems strange that this doesn't have either a reference to the
205 /// type/precision or a file/line pair for location info.
206 class DIEnumerator : public DIDescriptor {
208 explicit DIEnumerator(const MDNode *N = 0) : DIDescriptor(N) {}
210 StringRef getName() const { return getStringField(1); }
211 uint64_t getEnumValue() const { return getUInt64Field(2); }
214 /// DIType - This is a wrapper for a type.
215 /// FIXME: Types should be factored much better so that CV qualifiers and
216 /// others do not require a huge and empty descriptor full of zeros.
217 class DIType : public DIScope {
220 // This ctor is used when the Tag has already been validated by a derived
222 DIType(const MDNode *N, bool, bool) : DIScope(N) {}
226 /// Verify - Verify that a type descriptor is well formed.
229 explicit DIType(const MDNode *N);
233 DIScope getContext() const { return getFieldAs<DIScope>(1); }
234 StringRef getName() const { return getStringField(2); }
235 DICompileUnit getCompileUnit() const{
236 if (getVersion() == llvm::LLVMDebugVersion7)
237 return getFieldAs<DICompileUnit>(3);
239 DIFile F = getFieldAs<DIFile>(3);
240 return F.getCompileUnit();
242 unsigned getLineNumber() const { return getUnsignedField(4); }
243 uint64_t getSizeInBits() const { return getUInt64Field(5); }
244 uint64_t getAlignInBits() const { return getUInt64Field(6); }
245 // FIXME: Offset is only used for DW_TAG_member nodes. Making every type
246 // carry this is just plain insane.
247 uint64_t getOffsetInBits() const { return getUInt64Field(7); }
248 unsigned getFlags() const { return getUnsignedField(8); }
249 bool isPrivate() const {
250 return (getFlags() & FlagPrivate) != 0;
252 bool isProtected() const {
253 return (getFlags() & FlagProtected) != 0;
255 bool isForwardDecl() const {
256 return (getFlags() & FlagFwdDecl) != 0;
258 // isAppleBlock - Return true if this is the Apple Blocks extension.
259 bool isAppleBlockExtension() const {
260 return (getFlags() & FlagAppleBlock) != 0;
262 bool isBlockByrefStruct() const {
263 return (getFlags() & FlagBlockByrefStruct) != 0;
265 bool isVirtual() const {
266 return (getFlags() & FlagVirtual) != 0;
268 bool isArtificial() const {
269 return (getFlags() & FlagArtificial) != 0;
271 bool isValid() const {
272 return DbgNode && (isBasicType() || isDerivedType() || isCompositeType());
274 StringRef getFilename() const { return getCompileUnit().getFilename();}
275 StringRef getDirectory() const { return getCompileUnit().getDirectory();}
277 /// replaceAllUsesWith - Replace all uses of debug info referenced by
279 void replaceAllUsesWith(DIDescriptor &D);
281 /// print - print type.
282 void print(raw_ostream &OS) const;
284 /// dump - print type to dbgs() with a newline.
288 /// DIBasicType - A basic type, like 'int' or 'float'.
289 class DIBasicType : public DIType {
291 explicit DIBasicType(const MDNode *N = 0) : DIType(N) {}
293 unsigned getEncoding() const { return getUnsignedField(9); }
295 /// Verify - Verify that a basic type descriptor is well formed.
298 /// print - print basic type.
299 void print(raw_ostream &OS) const;
301 /// dump - print basic type to dbgs() with a newline.
305 /// DIDerivedType - A simple derived type, like a const qualified type,
306 /// a typedef, a pointer or reference, etc.
307 class DIDerivedType : public DIType {
309 explicit DIDerivedType(const MDNode *N, bool, bool)
310 : DIType(N, true, true) {}
312 explicit DIDerivedType(const MDNode *N = 0)
313 : DIType(N, true, true) {}
315 DIType getTypeDerivedFrom() const { return getFieldAs<DIType>(9); }
317 /// getOriginalTypeSize - If this type is derived from a base type then
318 /// return base type size.
319 uint64_t getOriginalTypeSize() const;
321 /// Verify - Verify that a derived type descriptor is well formed.
324 /// print - print derived type.
325 void print(raw_ostream &OS) const;
327 /// dump - print derived type to dbgs() with a newline.
331 /// DICompositeType - This descriptor holds a type that can refer to multiple
332 /// other types, like a function or struct.
333 /// FIXME: Why is this a DIDerivedType??
334 class DICompositeType : public DIDerivedType {
336 explicit DICompositeType(const MDNode *N = 0)
337 : DIDerivedType(N, true, true) {
338 if (N && !isCompositeType())
342 DIArray getTypeArray() const { return getFieldAs<DIArray>(10); }
343 unsigned getRunTimeLang() const { return getUnsignedField(11); }
344 DICompositeType getContainingType() const {
345 return getFieldAs<DICompositeType>(12);
348 /// Verify - Verify that a composite type descriptor is well formed.
351 /// print - print composite type.
352 void print(raw_ostream &OS) const;
354 /// dump - print composite type to dbgs() with a newline.
358 /// DISubprogram - This is a wrapper for a subprogram (e.g. a function).
359 class DISubprogram : public DIScope {
361 explicit DISubprogram(const MDNode *N = 0) : DIScope(N) {}
363 DIScope getContext() const { return getFieldAs<DIScope>(2); }
364 StringRef getName() const { return getStringField(3); }
365 StringRef getDisplayName() const { return getStringField(4); }
366 StringRef getLinkageName() const { return getStringField(5); }
367 DICompileUnit getCompileUnit() const{
368 if (getVersion() == llvm::LLVMDebugVersion7)
369 return getFieldAs<DICompileUnit>(6);
371 DIFile F = getFieldAs<DIFile>(6);
372 return F.getCompileUnit();
374 unsigned getLineNumber() const { return getUnsignedField(7); }
375 DICompositeType getType() const { return getFieldAs<DICompositeType>(8); }
377 /// getReturnTypeName - Subprogram return types are encoded either as
378 /// DIType or as DICompositeType.
379 StringRef getReturnTypeName() const {
380 DICompositeType DCT(getFieldAs<DICompositeType>(8));
382 DIArray A = DCT.getTypeArray();
383 DIType T(A.getElement(0));
386 DIType T(getFieldAs<DIType>(8));
390 /// isLocalToUnit - Return true if this subprogram is local to the current
391 /// compile unit, like 'static' in C.
392 unsigned isLocalToUnit() const { return getUnsignedField(9); }
393 unsigned isDefinition() const { return getUnsignedField(10); }
395 unsigned getVirtuality() const { return getUnsignedField(11); }
396 unsigned getVirtualIndex() const { return getUnsignedField(12); }
398 DICompositeType getContainingType() const {
399 return getFieldAs<DICompositeType>(13);
401 unsigned isArtificial() const {
402 if (getVersion() <= llvm::LLVMDebugVersion8)
403 return getUnsignedField(14);
404 return (getUnsignedField(14) & FlagArtificial) != 0;
406 /// isPrivate - Return true if this subprogram has "private"
407 /// access specifier.
408 bool isPrivate() const {
409 if (getVersion() <= llvm::LLVMDebugVersion8)
411 return (getUnsignedField(14) & FlagPrivate) != 0;
413 /// isProtected - Return true if this subprogram has "protected"
414 /// access specifier.
415 bool isProtected() const {
416 if (getVersion() <= llvm::LLVMDebugVersion8)
418 return (getUnsignedField(14) & FlagProtected) != 0;
420 /// isExplicit - Return true if this subprogram is marked as explicit.
421 bool isExplicit() const {
422 if (getVersion() <= llvm::LLVMDebugVersion8)
424 return (getUnsignedField(14) & FlagExplicit) != 0;
426 /// isPrototyped - Return true if this subprogram is prototyped.
427 bool isPrototyped() const {
428 if (getVersion() <= llvm::LLVMDebugVersion8)
430 return (getUnsignedField(14) & FlagPrototyped) != 0;
433 unsigned isOptimized() const;
435 StringRef getFilename() const {
436 if (getVersion() == llvm::LLVMDebugVersion7)
437 return getCompileUnit().getFilename();
439 DIFile F = getFieldAs<DIFile>(6);
440 return F.getFilename();
443 StringRef getDirectory() const {
444 if (getVersion() == llvm::LLVMDebugVersion7)
445 return getCompileUnit().getFilename();
447 DIFile F = getFieldAs<DIFile>(6);
448 return F.getDirectory();
451 /// Verify - Verify that a subprogram descriptor is well formed.
454 /// print - print subprogram.
455 void print(raw_ostream &OS) const;
457 /// dump - print subprogram to dbgs() with a newline.
460 /// describes - Return true if this subprogram provides debugging
461 /// information for the function F.
462 bool describes(const Function *F);
464 Function *getFunction() const { return getFunctionField(16); }
467 /// DIGlobalVariable - This is a wrapper for a global variable.
468 class DIGlobalVariable : public DIDescriptor {
470 explicit DIGlobalVariable(const MDNode *N = 0) : DIDescriptor(N) {}
472 DIScope getContext() const { return getFieldAs<DIScope>(2); }
473 StringRef getName() const { return getStringField(3); }
474 StringRef getDisplayName() const { return getStringField(4); }
475 StringRef getLinkageName() const { return getStringField(5); }
476 DICompileUnit getCompileUnit() const{
477 if (getVersion() == llvm::LLVMDebugVersion7)
478 return getFieldAs<DICompileUnit>(6);
480 DIFile F = getFieldAs<DIFile>(6);
481 return F.getCompileUnit();
484 unsigned getLineNumber() const { return getUnsignedField(7); }
485 DIType getType() const { return getFieldAs<DIType>(8); }
486 unsigned isLocalToUnit() const { return getUnsignedField(9); }
487 unsigned isDefinition() const { return getUnsignedField(10); }
489 GlobalVariable *getGlobal() const { return getGlobalVariableField(11); }
490 Constant *getConstant() const { return getConstantField(11); }
492 /// Verify - Verify that a global variable descriptor is well formed.
495 /// print - print global variable.
496 void print(raw_ostream &OS) const;
498 /// dump - print global variable to dbgs() with a newline.
502 /// DIVariable - This is a wrapper for a variable (e.g. parameter, local,
504 class DIVariable : public DIDescriptor {
506 explicit DIVariable(const MDNode *N = 0)
509 DIScope getContext() const { return getFieldAs<DIScope>(1); }
510 StringRef getName() const { return getStringField(2); }
511 DICompileUnit getCompileUnit() const{
512 if (getVersion() == llvm::LLVMDebugVersion7)
513 return getFieldAs<DICompileUnit>(3);
515 DIFile F = getFieldAs<DIFile>(3);
516 return F.getCompileUnit();
518 unsigned getLineNumber() const { return getUnsignedField(4); }
519 DIType getType() const { return getFieldAs<DIType>(5); }
521 /// isArtificial - Return true if this variable is marked as "artificial".
522 bool isArtificial() const {
523 if (getVersion() <= llvm::LLVMDebugVersion8)
525 return (getUnsignedField(6) & FlagArtificial) != 0;
529 /// Verify - Verify that a variable descriptor is well formed.
532 /// HasComplexAddr - Return true if the variable has a complex address.
533 bool hasComplexAddress() const {
534 return getNumAddrElements() > 0;
537 unsigned getNumAddrElements() const;
539 uint64_t getAddrElement(unsigned Idx) const {
540 return getUInt64Field(Idx+6);
543 /// isBlockByrefVariable - Return true if the variable was declared as
544 /// a "__block" variable (Apple Blocks).
545 bool isBlockByrefVariable() const {
546 return getType().isBlockByrefStruct();
549 /// isInlinedFnArgument - Return trule if this variable provides debugging
550 /// information for an inlined function arguments.
551 bool isInlinedFnArgument(const Function *CurFn);
553 /// print - print variable.
554 void print(raw_ostream &OS) const;
556 /// dump - print variable to dbgs() with a newline.
560 /// DILexicalBlock - This is a wrapper for a lexical block.
561 class DILexicalBlock : public DIScope {
563 explicit DILexicalBlock(const MDNode *N = 0) : DIScope(N) {}
564 DIScope getContext() const { return getFieldAs<DIScope>(1); }
565 unsigned getLineNumber() const { return getUnsignedField(2); }
566 unsigned getColumnNumber() const { return getUnsignedField(3); }
567 StringRef getDirectory() const {
568 DIFile F = getFieldAs<DIFile>(4);
569 StringRef dir = F.getDirectory();
570 return !dir.empty() ? dir : getContext().getDirectory();
572 StringRef getFilename() const {
573 DIFile F = getFieldAs<DIFile>(4);
574 StringRef filename = F.getFilename();
575 return !filename.empty() ? filename : getContext().getFilename();
579 /// DINameSpace - A wrapper for a C++ style name space.
580 class DINameSpace : public DIScope {
582 explicit DINameSpace(const MDNode *N = 0) : DIScope(N) {}
583 DIScope getContext() const { return getFieldAs<DIScope>(1); }
584 StringRef getName() const { return getStringField(2); }
585 StringRef getDirectory() const { return getContext().getDirectory(); }
586 StringRef getFilename() const { return getContext().getFilename(); }
587 DICompileUnit getCompileUnit() const{
588 if (getVersion() == llvm::LLVMDebugVersion7)
589 return getFieldAs<DICompileUnit>(3);
591 DIFile F = getFieldAs<DIFile>(3);
592 return F.getCompileUnit();
594 unsigned getLineNumber() const { return getUnsignedField(4); }
598 /// DILocation - This object holds location information. This object
599 /// is not associated with any DWARF tag.
600 class DILocation : public DIDescriptor {
602 explicit DILocation(const MDNode *N) : DIDescriptor(N) { }
604 unsigned getLineNumber() const { return getUnsignedField(0); }
605 unsigned getColumnNumber() const { return getUnsignedField(1); }
606 DIScope getScope() const { return getFieldAs<DIScope>(2); }
607 DILocation getOrigLocation() const { return getFieldAs<DILocation>(3); }
608 StringRef getFilename() const { return getScope().getFilename(); }
609 StringRef getDirectory() const { return getScope().getDirectory(); }
613 /// DIFactory - This object assists with the construction of the various
617 LLVMContext& VMContext;
619 Function *DeclareFn; // llvm.dbg.declare
620 Function *ValueFn; // llvm.dbg.value
622 DIFactory(const DIFactory &); // DO NOT IMPLEMENT
623 void operator=(const DIFactory&); // DO NOT IMPLEMENT
625 enum ComplexAddrKind { OpPlus=1, OpDeref };
627 explicit DIFactory(Module &m);
629 /// GetOrCreateArray - Create an descriptor for an array of descriptors.
630 /// This implicitly uniques the arrays created.
631 DIArray GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys);
633 /// GetOrCreateSubrange - Create a descriptor for a value range. This
634 /// implicitly uniques the values returned.
635 DISubrange GetOrCreateSubrange(int64_t Lo, int64_t Hi);
637 /// CreateUnspecifiedParameter - Create unspeicified type descriptor
638 /// for a subroutine type.
639 DIDescriptor CreateUnspecifiedParameter();
641 /// CreateCompileUnit - Create a new descriptor for the specified compile
643 DICompileUnit CreateCompileUnit(unsigned LangID,
648 bool isOptimized = false,
649 StringRef Flags = "",
650 unsigned RunTimeVer = 0);
652 /// CreateFile - Create a new descriptor for the specified file.
653 DIFile CreateFile(StringRef Filename, StringRef Directory,
656 /// CreateEnumerator - Create a single enumerator value.
657 DIEnumerator CreateEnumerator(StringRef Name, uint64_t Val);
659 /// CreateBasicType - Create a basic type like int, float, etc.
660 DIBasicType CreateBasicType(DIDescriptor Context, StringRef Name,
661 DIFile F, unsigned LineNumber,
662 uint64_t SizeInBits, uint64_t AlignInBits,
663 uint64_t OffsetInBits, unsigned Flags,
666 /// CreateBasicType - Create a basic type like int, float, etc.
667 DIBasicType CreateBasicTypeEx(DIDescriptor Context, StringRef Name,
668 DIFile F, unsigned LineNumber,
669 Constant *SizeInBits, Constant *AlignInBits,
670 Constant *OffsetInBits, unsigned Flags,
673 /// CreateDerivedType - Create a derived type like const qualified type,
674 /// pointer, typedef, etc.
675 DIDerivedType CreateDerivedType(unsigned Tag, DIDescriptor Context,
679 uint64_t SizeInBits, uint64_t AlignInBits,
680 uint64_t OffsetInBits, unsigned Flags,
683 /// CreateDerivedType - Create a derived type like const qualified type,
684 /// pointer, typedef, etc.
685 DIDerivedType CreateDerivedTypeEx(unsigned Tag, DIDescriptor Context,
689 Constant *SizeInBits,
690 Constant *AlignInBits,
691 Constant *OffsetInBits, unsigned Flags,
694 /// CreateCompositeType - Create a composite type like array, struct, etc.
695 DICompositeType CreateCompositeType(unsigned Tag, DIDescriptor Context,
700 uint64_t AlignInBits,
701 uint64_t OffsetInBits, unsigned Flags,
704 unsigned RunTimeLang = 0,
705 MDNode *ContainingType = 0);
707 /// CreateTemporaryType - Create a temporary forward-declared type.
708 DIType CreateTemporaryType();
710 /// CreateArtificialType - Create a new DIType with "artificial" flag set.
711 DIType CreateArtificialType(DIType Ty);
713 /// CreateCompositeType - Create a composite type like array, struct, etc.
714 DICompositeType CreateCompositeTypeEx(unsigned Tag, DIDescriptor Context,
718 Constant *SizeInBits,
719 Constant *AlignInBits,
720 Constant *OffsetInBits,
724 unsigned RunTimeLang = 0,
725 MDNode *ContainingType = 0);
727 /// CreateSubprogram - Create a new descriptor for the specified subprogram.
728 /// See comments in DISubprogram for descriptions of these fields.
729 DISubprogram CreateSubprogram(DIDescriptor Context, StringRef Name,
730 StringRef DisplayName,
731 StringRef LinkageName,
732 DIFile F, unsigned LineNo,
733 DIType Ty, bool isLocalToUnit,
737 DIType ContainingType = DIType(),
739 bool isOptimized = false,
742 /// CreateSubprogramDefinition - Create new subprogram descriptor for the
743 /// given declaration.
744 DISubprogram CreateSubprogramDefinition(DISubprogram &SPDeclaration);
746 /// CreateGlobalVariable - Create a new descriptor for the specified global.
748 CreateGlobalVariable(DIDescriptor Context, StringRef Name,
749 StringRef DisplayName,
750 StringRef LinkageName,
752 unsigned LineNo, DIType Ty, bool isLocalToUnit,
753 bool isDefinition, llvm::GlobalVariable *GV);
755 /// CreateGlobalVariable - Create a new descriptor for the specified constant.
757 CreateGlobalVariable(DIDescriptor Context, StringRef Name,
758 StringRef DisplayName,
759 StringRef LinkageName,
761 unsigned LineNo, DIType Ty, bool isLocalToUnit,
762 bool isDefinition, llvm::Constant *C);
764 /// CreateVariable - Create a new descriptor for the specified variable.
765 DIVariable CreateVariable(unsigned Tag, DIDescriptor Context,
767 DIFile F, unsigned LineNo,
768 DIType Ty, bool AlwaysPreserve = false,
771 /// CreateComplexVariable - Create a new descriptor for the specified
772 /// variable which has a complex address expression for its address.
773 DIVariable CreateComplexVariable(unsigned Tag, DIDescriptor Context,
774 StringRef Name, DIFile F, unsigned LineNo,
775 DIType Ty, Value *const *Addr,
778 /// CreateLexicalBlock - This creates a descriptor for a lexical block
779 /// with the specified parent context.
780 DILexicalBlock CreateLexicalBlock(DIDescriptor Context, DIFile F,
781 unsigned Line = 0, unsigned Col = 0);
783 /// CreateNameSpace - This creates new descriptor for a namespace
784 /// with the specified parent context.
785 DINameSpace CreateNameSpace(DIDescriptor Context, StringRef Name,
786 DIFile F, unsigned LineNo);
788 /// CreateLocation - Creates a debug info location.
789 DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
790 DIScope S, DILocation OrigLoc);
792 /// CreateLocation - Creates a debug info location.
793 DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
794 DIScope S, MDNode *OrigLoc = 0);
796 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
797 Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
798 BasicBlock *InsertAtEnd);
800 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
801 Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
802 Instruction *InsertBefore);
804 /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
805 Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
806 DIVariable D, BasicBlock *InsertAtEnd);
808 /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
809 Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
810 DIVariable D, Instruction *InsertBefore);
812 // RecordType - Record DIType in a module such that it is not lost even if
813 // it is not referenced through debug info anchors.
814 void RecordType(DIType T);
817 Constant *GetTagConstant(unsigned TAG);
820 bool getLocationInfo(const Value *V, std::string &DisplayName,
821 std::string &Type, unsigned &LineNo, std::string &File,
824 /// getDISubprogram - Find subprogram that is enclosing this scope.
825 DISubprogram getDISubprogram(const MDNode *Scope);
827 /// getDICompositeType - Find underlying composite type.
828 DICompositeType getDICompositeType(DIType T);
830 class DebugInfoFinder {
832 /// processModule - Process entire module and collect debug info
834 void processModule(Module &M);
837 /// processType - Process DIType.
838 void processType(DIType DT);
840 /// processLexicalBlock - Process DILexicalBlock.
841 void processLexicalBlock(DILexicalBlock LB);
843 /// processSubprogram - Process DISubprogram.
844 void processSubprogram(DISubprogram SP);
846 /// processDeclare - Process DbgDeclareInst.
847 void processDeclare(DbgDeclareInst *DDI);
849 /// processLocation - Process DILocation.
850 void processLocation(DILocation Loc);
852 /// addCompileUnit - Add compile unit into CUs.
853 bool addCompileUnit(DICompileUnit CU);
855 /// addGlobalVariable - Add global variable into GVs.
856 bool addGlobalVariable(DIGlobalVariable DIG);
858 // addSubprogram - Add subprgoram into SPs.
859 bool addSubprogram(DISubprogram SP);
861 /// addType - Add type into Tys.
862 bool addType(DIType DT);
865 typedef SmallVector<MDNode *, 8>::const_iterator iterator;
866 iterator compile_unit_begin() const { return CUs.begin(); }
867 iterator compile_unit_end() const { return CUs.end(); }
868 iterator subprogram_begin() const { return SPs.begin(); }
869 iterator subprogram_end() const { return SPs.end(); }
870 iterator global_variable_begin() const { return GVs.begin(); }
871 iterator global_variable_end() const { return GVs.end(); }
872 iterator type_begin() const { return TYs.begin(); }
873 iterator type_end() const { return TYs.end(); }
875 unsigned compile_unit_count() const { return CUs.size(); }
876 unsigned global_variable_count() const { return GVs.size(); }
877 unsigned subprogram_count() const { return SPs.size(); }
878 unsigned type_count() const { return TYs.size(); }
881 SmallVector<MDNode *, 8> CUs; // Compile Units
882 SmallVector<MDNode *, 8> SPs; // Subprograms
883 SmallVector<MDNode *, 8> GVs; // Global Variables;
884 SmallVector<MDNode *, 8> TYs; // Types
885 SmallPtrSet<MDNode *, 64> NodesSeen;
887 } // end namespace llvm