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 return getFieldAs<DIFile>(3).getCompileUnit();
241 unsigned getLineNumber() const { return getUnsignedField(4); }
242 uint64_t getSizeInBits() const { return getUInt64Field(5); }
243 uint64_t getAlignInBits() const { return getUInt64Field(6); }
244 // FIXME: Offset is only used for DW_TAG_member nodes. Making every type
245 // carry this is just plain insane.
246 uint64_t getOffsetInBits() const { return getUInt64Field(7); }
247 unsigned getFlags() const { return getUnsignedField(8); }
248 bool isPrivate() const {
249 return (getFlags() & FlagPrivate) != 0;
251 bool isProtected() const {
252 return (getFlags() & FlagProtected) != 0;
254 bool isForwardDecl() const {
255 return (getFlags() & FlagFwdDecl) != 0;
257 // isAppleBlock - Return true if this is the Apple Blocks extension.
258 bool isAppleBlockExtension() const {
259 return (getFlags() & FlagAppleBlock) != 0;
261 bool isBlockByrefStruct() const {
262 return (getFlags() & FlagBlockByrefStruct) != 0;
264 bool isVirtual() const {
265 return (getFlags() & FlagVirtual) != 0;
267 bool isArtificial() const {
268 return (getFlags() & FlagArtificial) != 0;
270 bool isValid() const {
271 return DbgNode && (isBasicType() || isDerivedType() || isCompositeType());
273 StringRef getDirectory() const {
274 if (getVersion() == llvm::LLVMDebugVersion7)
275 return getCompileUnit().getDirectory();
277 return getFieldAs<DIFile>(3).getDirectory();
279 StringRef getFilename() const {
280 if (getVersion() == llvm::LLVMDebugVersion7)
281 return getCompileUnit().getFilename();
283 return getFieldAs<DIFile>(3).getFilename();
286 /// replaceAllUsesWith - Replace all uses of debug info referenced by
288 void replaceAllUsesWith(DIDescriptor &D);
290 /// print - print type.
291 void print(raw_ostream &OS) const;
293 /// dump - print type to dbgs() with a newline.
297 /// DIBasicType - A basic type, like 'int' or 'float'.
298 class DIBasicType : public DIType {
300 explicit DIBasicType(const MDNode *N = 0) : DIType(N) {}
302 unsigned getEncoding() const { return getUnsignedField(9); }
304 /// Verify - Verify that a basic type descriptor is well formed.
307 /// print - print basic type.
308 void print(raw_ostream &OS) const;
310 /// dump - print basic type to dbgs() with a newline.
314 /// DIDerivedType - A simple derived type, like a const qualified type,
315 /// a typedef, a pointer or reference, etc.
316 class DIDerivedType : public DIType {
318 explicit DIDerivedType(const MDNode *N, bool, bool)
319 : DIType(N, true, true) {}
321 explicit DIDerivedType(const MDNode *N = 0)
322 : DIType(N, true, true) {}
324 DIType getTypeDerivedFrom() const { return getFieldAs<DIType>(9); }
326 /// getOriginalTypeSize - If this type is derived from a base type then
327 /// return base type size.
328 uint64_t getOriginalTypeSize() const;
330 /// Verify - Verify that a derived type descriptor is well formed.
333 /// print - print derived type.
334 void print(raw_ostream &OS) const;
336 /// dump - print derived type to dbgs() with a newline.
340 /// DICompositeType - This descriptor holds a type that can refer to multiple
341 /// other types, like a function or struct.
342 /// FIXME: Why is this a DIDerivedType??
343 class DICompositeType : public DIDerivedType {
345 explicit DICompositeType(const MDNode *N = 0)
346 : DIDerivedType(N, true, true) {
347 if (N && !isCompositeType())
351 DIArray getTypeArray() const { return getFieldAs<DIArray>(10); }
352 unsigned getRunTimeLang() const { return getUnsignedField(11); }
353 DICompositeType getContainingType() const {
354 return getFieldAs<DICompositeType>(12);
357 /// Verify - Verify that a composite type descriptor is well formed.
360 /// print - print composite type.
361 void print(raw_ostream &OS) const;
363 /// dump - print composite type to dbgs() with a newline.
367 /// DISubprogram - This is a wrapper for a subprogram (e.g. a function).
368 class DISubprogram : public DIScope {
370 explicit DISubprogram(const MDNode *N = 0) : DIScope(N) {}
372 DIScope getContext() const { return getFieldAs<DIScope>(2); }
373 StringRef getName() const { return getStringField(3); }
374 StringRef getDisplayName() const { return getStringField(4); }
375 StringRef getLinkageName() const { return getStringField(5); }
376 DICompileUnit getCompileUnit() const{
377 if (getVersion() == llvm::LLVMDebugVersion7)
378 return getFieldAs<DICompileUnit>(6);
380 return getFieldAs<DIFile>(6).getCompileUnit();
382 unsigned getLineNumber() const { return getUnsignedField(7); }
383 DICompositeType getType() const { return getFieldAs<DICompositeType>(8); }
385 /// getReturnTypeName - Subprogram return types are encoded either as
386 /// DIType or as DICompositeType.
387 StringRef getReturnTypeName() const {
388 DICompositeType DCT(getFieldAs<DICompositeType>(8));
390 DIArray A = DCT.getTypeArray();
391 DIType T(A.getElement(0));
394 DIType T(getFieldAs<DIType>(8));
398 /// isLocalToUnit - Return true if this subprogram is local to the current
399 /// compile unit, like 'static' in C.
400 unsigned isLocalToUnit() const { return getUnsignedField(9); }
401 unsigned isDefinition() const { return getUnsignedField(10); }
403 unsigned getVirtuality() const { return getUnsignedField(11); }
404 unsigned getVirtualIndex() const { return getUnsignedField(12); }
406 DICompositeType getContainingType() const {
407 return getFieldAs<DICompositeType>(13);
409 unsigned isArtificial() const {
410 if (getVersion() <= llvm::LLVMDebugVersion8)
411 return getUnsignedField(14);
412 return (getUnsignedField(14) & FlagArtificial) != 0;
414 /// isPrivate - Return true if this subprogram has "private"
415 /// access specifier.
416 bool isPrivate() const {
417 if (getVersion() <= llvm::LLVMDebugVersion8)
419 return (getUnsignedField(14) & FlagPrivate) != 0;
421 /// isProtected - Return true if this subprogram has "protected"
422 /// access specifier.
423 bool isProtected() const {
424 if (getVersion() <= llvm::LLVMDebugVersion8)
426 return (getUnsignedField(14) & FlagProtected) != 0;
428 /// isExplicit - Return true if this subprogram is marked as explicit.
429 bool isExplicit() const {
430 if (getVersion() <= llvm::LLVMDebugVersion8)
432 return (getUnsignedField(14) & FlagExplicit) != 0;
434 /// isPrototyped - Return true if this subprogram is prototyped.
435 bool isPrototyped() const {
436 if (getVersion() <= llvm::LLVMDebugVersion8)
438 return (getUnsignedField(14) & FlagPrototyped) != 0;
441 unsigned isOptimized() const;
443 StringRef getFilename() const {
444 if (getVersion() == llvm::LLVMDebugVersion7)
445 return getCompileUnit().getFilename();
447 return getFieldAs<DIFile>(6).getFilename();
450 StringRef getDirectory() const {
451 if (getVersion() == llvm::LLVMDebugVersion7)
452 return getCompileUnit().getFilename();
454 return getFieldAs<DIFile>(6).getDirectory();
457 /// Verify - Verify that a subprogram descriptor is well formed.
460 /// print - print subprogram.
461 void print(raw_ostream &OS) const;
463 /// dump - print subprogram to dbgs() with a newline.
466 /// describes - Return true if this subprogram provides debugging
467 /// information for the function F.
468 bool describes(const Function *F);
470 Function *getFunction() const { return getFunctionField(16); }
473 /// DIGlobalVariable - This is a wrapper for a global variable.
474 class DIGlobalVariable : public DIDescriptor {
476 explicit DIGlobalVariable(const MDNode *N = 0) : DIDescriptor(N) {}
478 DIScope getContext() const { return getFieldAs<DIScope>(2); }
479 StringRef getName() const { return getStringField(3); }
480 StringRef getDisplayName() const { return getStringField(4); }
481 StringRef getLinkageName() const { return getStringField(5); }
482 DICompileUnit getCompileUnit() const{
483 if (getVersion() == llvm::LLVMDebugVersion7)
484 return getFieldAs<DICompileUnit>(6);
486 DIFile F = getFieldAs<DIFile>(6);
487 return F.getCompileUnit();
490 unsigned getLineNumber() const { return getUnsignedField(7); }
491 DIType getType() const { return getFieldAs<DIType>(8); }
492 unsigned isLocalToUnit() const { return getUnsignedField(9); }
493 unsigned isDefinition() const { return getUnsignedField(10); }
495 GlobalVariable *getGlobal() const { return getGlobalVariableField(11); }
496 Constant *getConstant() const { return getConstantField(11); }
498 /// Verify - Verify that a global variable descriptor is well formed.
501 /// print - print global variable.
502 void print(raw_ostream &OS) const;
504 /// dump - print global variable to dbgs() with a newline.
508 /// DIVariable - This is a wrapper for a variable (e.g. parameter, local,
510 class DIVariable : public DIDescriptor {
512 explicit DIVariable(const MDNode *N = 0)
515 DIScope getContext() const { return getFieldAs<DIScope>(1); }
516 StringRef getName() const { return getStringField(2); }
517 DICompileUnit getCompileUnit() const{
518 if (getVersion() == llvm::LLVMDebugVersion7)
519 return getFieldAs<DICompileUnit>(3);
521 DIFile F = getFieldAs<DIFile>(3);
522 return F.getCompileUnit();
524 unsigned getLineNumber() const { return getUnsignedField(4); }
525 DIType getType() const { return getFieldAs<DIType>(5); }
527 /// isArtificial - Return true if this variable is marked as "artificial".
528 bool isArtificial() const {
529 if (getVersion() <= llvm::LLVMDebugVersion8)
531 return (getUnsignedField(6) & FlagArtificial) != 0;
535 /// Verify - Verify that a variable descriptor is well formed.
538 /// HasComplexAddr - Return true if the variable has a complex address.
539 bool hasComplexAddress() const {
540 return getNumAddrElements() > 0;
543 unsigned getNumAddrElements() const;
545 uint64_t getAddrElement(unsigned Idx) const {
546 return getUInt64Field(Idx+6);
549 /// isBlockByrefVariable - Return true if the variable was declared as
550 /// a "__block" variable (Apple Blocks).
551 bool isBlockByrefVariable() const {
552 return getType().isBlockByrefStruct();
555 /// isInlinedFnArgument - Return trule if this variable provides debugging
556 /// information for an inlined function arguments.
557 bool isInlinedFnArgument(const Function *CurFn);
559 /// print - print variable.
560 void print(raw_ostream &OS) const;
562 /// dump - print variable to dbgs() with a newline.
566 /// DILexicalBlock - This is a wrapper for a lexical block.
567 class DILexicalBlock : public DIScope {
569 explicit DILexicalBlock(const MDNode *N = 0) : DIScope(N) {}
570 DIScope getContext() const { return getFieldAs<DIScope>(1); }
571 unsigned getLineNumber() const { return getUnsignedField(2); }
572 unsigned getColumnNumber() const { return getUnsignedField(3); }
573 StringRef getDirectory() const {
574 StringRef dir = getFieldAs<DIFile>(4).getDirectory();
575 return !dir.empty() ? dir : getContext().getDirectory();
577 StringRef getFilename() const {
578 StringRef filename = getFieldAs<DIFile>(4).getFilename();
579 return !filename.empty() ? filename : getContext().getFilename();
583 /// DINameSpace - A wrapper for a C++ style name space.
584 class DINameSpace : public DIScope {
586 explicit DINameSpace(const MDNode *N = 0) : DIScope(N) {}
587 DIScope getContext() const { return getFieldAs<DIScope>(1); }
588 StringRef getName() const { return getStringField(2); }
589 StringRef getDirectory() const {
590 return getFieldAs<DIFile>(3).getDirectory();
592 StringRef getFilename() const {
593 return getFieldAs<DIFile>(3).getFilename();
595 DICompileUnit getCompileUnit() const{
596 if (getVersion() == llvm::LLVMDebugVersion7)
597 return getFieldAs<DICompileUnit>(3);
599 return getFieldAs<DIFile>(3).getCompileUnit();
601 unsigned getLineNumber() const { return getUnsignedField(4); }
605 /// DILocation - This object holds location information. This object
606 /// is not associated with any DWARF tag.
607 class DILocation : public DIDescriptor {
609 explicit DILocation(const MDNode *N) : DIDescriptor(N) { }
611 unsigned getLineNumber() const { return getUnsignedField(0); }
612 unsigned getColumnNumber() const { return getUnsignedField(1); }
613 DIScope getScope() const { return getFieldAs<DIScope>(2); }
614 DILocation getOrigLocation() const { return getFieldAs<DILocation>(3); }
615 StringRef getFilename() const { return getScope().getFilename(); }
616 StringRef getDirectory() const { return getScope().getDirectory(); }
620 /// DIFactory - This object assists with the construction of the various
624 LLVMContext& VMContext;
626 Function *DeclareFn; // llvm.dbg.declare
627 Function *ValueFn; // llvm.dbg.value
629 DIFactory(const DIFactory &); // DO NOT IMPLEMENT
630 void operator=(const DIFactory&); // DO NOT IMPLEMENT
632 enum ComplexAddrKind { OpPlus=1, OpDeref };
634 explicit DIFactory(Module &m);
636 /// GetOrCreateArray - Create an descriptor for an array of descriptors.
637 /// This implicitly uniques the arrays created.
638 DIArray GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys);
640 /// GetOrCreateSubrange - Create a descriptor for a value range. This
641 /// implicitly uniques the values returned.
642 DISubrange GetOrCreateSubrange(int64_t Lo, int64_t Hi);
644 /// CreateUnspecifiedParameter - Create unspeicified type descriptor
645 /// for a subroutine type.
646 DIDescriptor CreateUnspecifiedParameter();
648 /// CreateCompileUnit - Create a new descriptor for the specified compile
650 DICompileUnit CreateCompileUnit(unsigned LangID,
655 bool isOptimized = false,
656 StringRef Flags = "",
657 unsigned RunTimeVer = 0);
659 /// CreateFile - Create a new descriptor for the specified file.
660 DIFile CreateFile(StringRef Filename, StringRef Directory,
663 /// CreateEnumerator - Create a single enumerator value.
664 DIEnumerator CreateEnumerator(StringRef Name, uint64_t Val);
666 /// CreateBasicType - Create a basic type like int, float, etc.
667 DIBasicType CreateBasicType(DIDescriptor Context, StringRef Name,
668 DIFile F, unsigned LineNumber,
669 uint64_t SizeInBits, uint64_t AlignInBits,
670 uint64_t OffsetInBits, unsigned Flags,
673 /// CreateBasicType - Create a basic type like int, float, etc.
674 DIBasicType CreateBasicTypeEx(DIDescriptor Context, StringRef Name,
675 DIFile F, unsigned LineNumber,
676 Constant *SizeInBits, Constant *AlignInBits,
677 Constant *OffsetInBits, unsigned Flags,
680 /// CreateDerivedType - Create a derived type like const qualified type,
681 /// pointer, typedef, etc.
682 DIDerivedType CreateDerivedType(unsigned Tag, DIDescriptor Context,
686 uint64_t SizeInBits, uint64_t AlignInBits,
687 uint64_t OffsetInBits, unsigned Flags,
690 /// CreateDerivedType - Create a derived type like const qualified type,
691 /// pointer, typedef, etc.
692 DIDerivedType CreateDerivedTypeEx(unsigned Tag, DIDescriptor Context,
696 Constant *SizeInBits,
697 Constant *AlignInBits,
698 Constant *OffsetInBits, unsigned Flags,
701 /// CreateCompositeType - Create a composite type like array, struct, etc.
702 DICompositeType CreateCompositeType(unsigned Tag, DIDescriptor Context,
707 uint64_t AlignInBits,
708 uint64_t OffsetInBits, unsigned Flags,
711 unsigned RunTimeLang = 0,
712 MDNode *ContainingType = 0);
714 /// CreateTemporaryType - Create a temporary forward-declared type.
715 DIType CreateTemporaryType();
717 /// CreateArtificialType - Create a new DIType with "artificial" flag set.
718 DIType CreateArtificialType(DIType Ty);
720 /// CreateCompositeType - Create a composite type like array, struct, etc.
721 DICompositeType CreateCompositeTypeEx(unsigned Tag, DIDescriptor Context,
725 Constant *SizeInBits,
726 Constant *AlignInBits,
727 Constant *OffsetInBits,
731 unsigned RunTimeLang = 0,
732 MDNode *ContainingType = 0);
734 /// CreateSubprogram - Create a new descriptor for the specified subprogram.
735 /// See comments in DISubprogram for descriptions of these fields.
736 DISubprogram CreateSubprogram(DIDescriptor Context, StringRef Name,
737 StringRef DisplayName,
738 StringRef LinkageName,
739 DIFile F, unsigned LineNo,
740 DIType Ty, bool isLocalToUnit,
744 DIType ContainingType = DIType(),
746 bool isOptimized = false,
749 /// CreateSubprogramDefinition - Create new subprogram descriptor for the
750 /// given declaration.
751 DISubprogram CreateSubprogramDefinition(DISubprogram &SPDeclaration);
753 /// CreateGlobalVariable - Create a new descriptor for the specified global.
755 CreateGlobalVariable(DIDescriptor Context, StringRef Name,
756 StringRef DisplayName,
757 StringRef LinkageName,
759 unsigned LineNo, DIType Ty, bool isLocalToUnit,
760 bool isDefinition, llvm::GlobalVariable *GV);
762 /// CreateGlobalVariable - Create a new descriptor for the specified constant.
764 CreateGlobalVariable(DIDescriptor Context, StringRef Name,
765 StringRef DisplayName,
766 StringRef LinkageName,
768 unsigned LineNo, DIType Ty, bool isLocalToUnit,
769 bool isDefinition, llvm::Constant *C);
771 /// CreateVariable - Create a new descriptor for the specified variable.
772 DIVariable CreateVariable(unsigned Tag, DIDescriptor Context,
774 DIFile F, unsigned LineNo,
775 DIType Ty, bool AlwaysPreserve = false,
778 /// CreateComplexVariable - Create a new descriptor for the specified
779 /// variable which has a complex address expression for its address.
780 DIVariable CreateComplexVariable(unsigned Tag, DIDescriptor Context,
781 StringRef Name, DIFile F, unsigned LineNo,
782 DIType Ty, Value *const *Addr,
785 /// CreateLexicalBlock - This creates a descriptor for a lexical block
786 /// with the specified parent context.
787 DILexicalBlock CreateLexicalBlock(DIDescriptor Context, DIFile F,
788 unsigned Line = 0, unsigned Col = 0);
790 /// CreateNameSpace - This creates new descriptor for a namespace
791 /// with the specified parent context.
792 DINameSpace CreateNameSpace(DIDescriptor Context, StringRef Name,
793 DIFile F, unsigned LineNo);
795 /// CreateLocation - Creates a debug info location.
796 DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
797 DIScope S, DILocation OrigLoc);
799 /// CreateLocation - Creates a debug info location.
800 DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
801 DIScope S, MDNode *OrigLoc = 0);
803 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
804 Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
805 BasicBlock *InsertAtEnd);
807 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
808 Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
809 Instruction *InsertBefore);
811 /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
812 Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
813 DIVariable D, BasicBlock *InsertAtEnd);
815 /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
816 Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
817 DIVariable D, Instruction *InsertBefore);
819 // RecordType - Record DIType in a module such that it is not lost even if
820 // it is not referenced through debug info anchors.
821 void RecordType(DIType T);
824 Constant *GetTagConstant(unsigned TAG);
827 bool getLocationInfo(const Value *V, std::string &DisplayName,
828 std::string &Type, unsigned &LineNo, std::string &File,
831 /// getDISubprogram - Find subprogram that is enclosing this scope.
832 DISubprogram getDISubprogram(const MDNode *Scope);
834 /// getDICompositeType - Find underlying composite type.
835 DICompositeType getDICompositeType(DIType T);
837 class DebugInfoFinder {
839 /// processModule - Process entire module and collect debug info
841 void processModule(Module &M);
844 /// processType - Process DIType.
845 void processType(DIType DT);
847 /// processLexicalBlock - Process DILexicalBlock.
848 void processLexicalBlock(DILexicalBlock LB);
850 /// processSubprogram - Process DISubprogram.
851 void processSubprogram(DISubprogram SP);
853 /// processDeclare - Process DbgDeclareInst.
854 void processDeclare(DbgDeclareInst *DDI);
856 /// processLocation - Process DILocation.
857 void processLocation(DILocation Loc);
859 /// addCompileUnit - Add compile unit into CUs.
860 bool addCompileUnit(DICompileUnit CU);
862 /// addGlobalVariable - Add global variable into GVs.
863 bool addGlobalVariable(DIGlobalVariable DIG);
865 // addSubprogram - Add subprgoram into SPs.
866 bool addSubprogram(DISubprogram SP);
868 /// addType - Add type into Tys.
869 bool addType(DIType DT);
872 typedef SmallVector<MDNode *, 8>::const_iterator iterator;
873 iterator compile_unit_begin() const { return CUs.begin(); }
874 iterator compile_unit_end() const { return CUs.end(); }
875 iterator subprogram_begin() const { return SPs.begin(); }
876 iterator subprogram_end() const { return SPs.end(); }
877 iterator global_variable_begin() const { return GVs.begin(); }
878 iterator global_variable_end() const { return GVs.end(); }
879 iterator type_begin() const { return TYs.begin(); }
880 iterator type_end() const { return TYs.end(); }
882 unsigned compile_unit_count() const { return CUs.size(); }
883 unsigned global_variable_count() const { return GVs.size(); }
884 unsigned subprogram_count() const { return SPs.size(); }
885 unsigned type_count() const { return TYs.size(); }
888 SmallVector<MDNode *, 8> CUs; // Compile Units
889 SmallVector<MDNode *, 8> SPs; // Subprograms
890 SmallVector<MDNode *, 8> GVs; // Global Variables;
891 SmallVector<MDNode *, 8> TYs; // Types
892 SmallPtrSet<MDNode *, 64> NodesSeen;
894 } // end namespace llvm