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"
39 /// DIDescriptor - A thin wraper around MDNode to access encoded debug info.
40 /// This should not be stored in a container, because underly MDNode may
41 /// change in certain situations.
44 const MDNode *DbgNode;
46 StringRef getStringField(unsigned Elt) const;
47 unsigned getUnsignedField(unsigned Elt) const {
48 return (unsigned)getUInt64Field(Elt);
50 uint64_t getUInt64Field(unsigned Elt) const;
51 DIDescriptor getDescriptorField(unsigned Elt) const;
53 template <typename DescTy>
54 DescTy getFieldAs(unsigned Elt) const {
55 return DescTy(getDescriptorField(Elt));
58 GlobalVariable *getGlobalVariableField(unsigned Elt) const;
61 explicit DIDescriptor() : DbgNode(0) {}
62 explicit DIDescriptor(const MDNode *N) : DbgNode(N) {}
64 bool Verify() const { return DbgNode != 0; }
66 operator MDNode *() const { return const_cast<MDNode*>(DbgNode); }
67 MDNode *operator ->() const { return const_cast<MDNode*>(DbgNode); }
69 unsigned getVersion() const {
70 return getUnsignedField(0) & LLVMDebugVersionMask;
73 unsigned getTag() const {
74 return getUnsignedField(0) & ~LLVMDebugVersionMask;
77 /// print - print descriptor.
78 void print(raw_ostream &OS) const;
80 /// dump - print descriptor to dbgs() with a newline.
83 bool isDerivedType() const;
84 bool isCompositeType() const;
85 bool isBasicType() const;
86 bool isVariable() const;
87 bool isSubprogram() const;
88 bool isGlobalVariable() const;
91 bool isCompileUnit() const;
92 bool isNameSpace() const;
93 bool isLexicalBlock() const;
94 bool isSubrange() const;
95 bool isEnumerator() const;
97 bool isGlobal() const;
100 /// DISubrange - This is used to represent ranges, for array bounds.
101 class DISubrange : public DIDescriptor {
103 explicit DISubrange(const MDNode *N = 0) : DIDescriptor(N) {}
105 int64_t getLo() const { return (int64_t)getUInt64Field(1); }
106 int64_t getHi() const { return (int64_t)getUInt64Field(2); }
109 /// DIArray - This descriptor holds an array of descriptors.
110 class DIArray : public DIDescriptor {
112 explicit DIArray(const MDNode *N = 0)
115 unsigned getNumElements() const;
116 DIDescriptor getElement(unsigned Idx) const {
117 return getDescriptorField(Idx);
121 /// DIScope - A base class for various scopes.
122 class DIScope : public DIDescriptor {
124 explicit DIScope(const MDNode *N = 0) : DIDescriptor (N) {}
125 virtual ~DIScope() {}
127 StringRef getFilename() const;
128 StringRef getDirectory() const;
131 /// DICompileUnit - A wrapper for a compile unit.
132 class DICompileUnit : public DIScope {
134 explicit DICompileUnit(const MDNode *N = 0) : DIScope(N) {}
136 unsigned getLanguage() const { return getUnsignedField(2); }
137 StringRef getFilename() const { return getStringField(3); }
138 StringRef getDirectory() const { return getStringField(4); }
139 StringRef getProducer() const { return getStringField(5); }
141 /// isMain - Each input file is encoded as a separate compile unit in LLVM
142 /// debugging information output. However, many target specific tool chains
143 /// prefer to encode only one compile unit in an object file. In this
144 /// situation, the LLVM code generator will include debugging information
145 /// entities in the compile unit that is marked as main compile unit. The
146 /// code generator accepts maximum one main compile unit per module. If a
147 /// module does not contain any main compile unit then the code generator
148 /// will emit multiple compile units in the output object file.
150 bool isMain() const { return getUnsignedField(6); }
151 bool isOptimized() const { return getUnsignedField(7); }
152 StringRef getFlags() const { return getStringField(8); }
153 unsigned getRunTimeVersion() const { return getUnsignedField(9); }
155 /// Verify - Verify that a compile unit is well formed.
158 /// print - print compile unit.
159 void print(raw_ostream &OS) const;
161 /// dump - print compile unit to dbgs() with a newline.
165 /// DIFile - This is a wrapper for a file.
166 class DIFile : public DIScope {
168 explicit DIFile(const MDNode *N = 0) : DIScope(N) {
169 if (DbgNode && !isFile())
172 StringRef getFilename() const { return getStringField(1); }
173 StringRef getDirectory() const { return getStringField(2); }
174 DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
177 /// DIEnumerator - A wrapper for an enumerator (e.g. X and Y in 'enum {X,Y}').
178 /// FIXME: it seems strange that this doesn't have either a reference to the
179 /// type/precision or a file/line pair for location info.
180 class DIEnumerator : public DIDescriptor {
182 explicit DIEnumerator(const MDNode *N = 0) : DIDescriptor(N) {}
184 StringRef getName() const { return getStringField(1); }
185 uint64_t getEnumValue() const { return getUInt64Field(2); }
188 /// DIType - This is a wrapper for a type.
189 /// FIXME: Types should be factored much better so that CV qualifiers and
190 /// others do not require a huge and empty descriptor full of zeros.
191 class DIType : public DIScope {
194 FlagPrivate = 1 << 0,
195 FlagProtected = 1 << 1,
196 FlagFwdDecl = 1 << 2,
197 FlagAppleBlock = 1 << 3,
198 FlagBlockByrefStruct = 1 << 4,
199 FlagVirtual = 1 << 5,
200 FlagArtificial = 1 << 6 // To identify artificial arguments in
201 // a subroutine type. e.g. "this" in c++.
205 // This ctor is used when the Tag has already been validated by a derived
207 DIType(const MDNode *N, bool, bool) : DIScope(N) {}
211 /// Verify - Verify that a type descriptor is well formed.
214 explicit DIType(const MDNode *N);
218 DIScope getContext() const { return getFieldAs<DIScope>(1); }
219 StringRef getName() const { return getStringField(2); }
220 DICompileUnit getCompileUnit() const{
221 if (getVersion() == llvm::LLVMDebugVersion7)
222 return getFieldAs<DICompileUnit>(3);
224 DIFile F = getFieldAs<DIFile>(3);
225 return F.getCompileUnit();
227 unsigned getLineNumber() const { return getUnsignedField(4); }
228 uint64_t getSizeInBits() const { return getUInt64Field(5); }
229 uint64_t getAlignInBits() const { return getUInt64Field(6); }
230 // FIXME: Offset is only used for DW_TAG_member nodes. Making every type
231 // carry this is just plain insane.
232 uint64_t getOffsetInBits() const { return getUInt64Field(7); }
233 unsigned getFlags() const { return getUnsignedField(8); }
234 bool isPrivate() const {
235 return (getFlags() & FlagPrivate) != 0;
237 bool isProtected() const {
238 return (getFlags() & FlagProtected) != 0;
240 bool isForwardDecl() const {
241 return (getFlags() & FlagFwdDecl) != 0;
243 // isAppleBlock - Return true if this is the Apple Blocks extension.
244 bool isAppleBlockExtension() const {
245 return (getFlags() & FlagAppleBlock) != 0;
247 bool isBlockByrefStruct() const {
248 return (getFlags() & FlagBlockByrefStruct) != 0;
250 bool isVirtual() const {
251 return (getFlags() & FlagVirtual) != 0;
253 bool isArtificial() const {
254 return (getFlags() & FlagArtificial) != 0;
256 bool isValid() const {
257 return DbgNode && (isBasicType() || isDerivedType() || isCompositeType());
259 StringRef getFilename() const { return getCompileUnit().getFilename();}
260 StringRef getDirectory() const { return getCompileUnit().getDirectory();}
262 /// print - print type.
263 void print(raw_ostream &OS) const;
265 /// dump - print type to dbgs() with a newline.
269 /// DIBasicType - A basic type, like 'int' or 'float'.
270 class DIBasicType : public DIType {
272 explicit DIBasicType(const MDNode *N = 0) : DIType(N) {}
274 unsigned getEncoding() const { return getUnsignedField(9); }
276 /// print - print basic type.
277 void print(raw_ostream &OS) const;
279 /// dump - print basic type to dbgs() with a newline.
283 /// DIDerivedType - A simple derived type, like a const qualified type,
284 /// a typedef, a pointer or reference, etc.
285 class DIDerivedType : public DIType {
287 explicit DIDerivedType(const MDNode *N, bool, bool)
288 : DIType(N, true, true) {}
290 explicit DIDerivedType(const MDNode *N = 0)
291 : DIType(N, true, true) {}
293 DIType getTypeDerivedFrom() const { return getFieldAs<DIType>(9); }
295 /// getOriginalTypeSize - If this type is derived from a base type then
296 /// return base type size.
297 uint64_t getOriginalTypeSize() const;
299 /// print - print derived type.
300 void print(raw_ostream &OS) const;
302 /// dump - print derived type to dbgs() with a newline.
305 /// replaceAllUsesWith - Replace all uses of debug info referenced by
306 /// this descriptor. After this completes, the current debug info value
308 void replaceAllUsesWith(DIDescriptor &D);
311 /// DICompositeType - This descriptor holds a type that can refer to multiple
312 /// other types, like a function or struct.
313 /// FIXME: Why is this a DIDerivedType??
314 class DICompositeType : public DIDerivedType {
316 explicit DICompositeType(const MDNode *N = 0)
317 : DIDerivedType(N, true, true) {
318 if (N && !isCompositeType())
322 DIArray getTypeArray() const { return getFieldAs<DIArray>(10); }
323 unsigned getRunTimeLang() const { return getUnsignedField(11); }
324 DICompositeType getContainingType() const {
325 return getFieldAs<DICompositeType>(12);
328 /// Verify - Verify that a composite type descriptor is well formed.
331 /// print - print composite type.
332 void print(raw_ostream &OS) const;
334 /// dump - print composite type to dbgs() with a newline.
338 /// DIGlobal - This is a common class for global variables and subprograms.
339 class DIGlobal : public DIDescriptor {
341 explicit DIGlobal(const MDNode *N) : DIDescriptor(N) {}
344 virtual ~DIGlobal() {}
346 DIScope getContext() const { return getFieldAs<DIScope>(2); }
347 StringRef getName() const { return getStringField(3); }
348 StringRef getDisplayName() const { return getStringField(4); }
349 StringRef getLinkageName() const { return getStringField(5); }
350 DICompileUnit getCompileUnit() const{
351 if (getVersion() == llvm::LLVMDebugVersion7)
352 return getFieldAs<DICompileUnit>(6);
354 DIFile F = getFieldAs<DIFile>(6);
355 return F.getCompileUnit();
358 unsigned getLineNumber() const { return getUnsignedField(7); }
359 DIType getType() const { return getFieldAs<DIType>(8); }
361 /// isLocalToUnit - Return true if this subprogram is local to the current
362 /// compile unit, like 'static' in C.
363 unsigned isLocalToUnit() const { return getUnsignedField(9); }
364 unsigned isDefinition() const { return getUnsignedField(10); }
366 /// print - print global.
367 void print(raw_ostream &OS) const;
369 /// dump - print global to dbgs() with a newline.
373 /// DISubprogram - This is a wrapper for a subprogram (e.g. a function).
374 class DISubprogram : public DIScope {
376 explicit DISubprogram(const MDNode *N = 0) : DIScope(N) {}
378 DIScope getContext() const { return getFieldAs<DIScope>(2); }
379 StringRef getName() const { return getStringField(3); }
380 StringRef getDisplayName() const { return getStringField(4); }
381 StringRef getLinkageName() const { return getStringField(5); }
382 DICompileUnit getCompileUnit() const{
383 if (getVersion() == llvm::LLVMDebugVersion7)
384 return getFieldAs<DICompileUnit>(6);
386 DIFile F = getFieldAs<DIFile>(6);
387 return F.getCompileUnit();
389 unsigned getLineNumber() const { return getUnsignedField(7); }
390 DICompositeType getType() const { return getFieldAs<DICompositeType>(8); }
392 /// getReturnTypeName - Subprogram return types are encoded either as
393 /// DIType or as DICompositeType.
394 StringRef getReturnTypeName() const {
395 DICompositeType DCT(getFieldAs<DICompositeType>(8));
397 DIArray A = DCT.getTypeArray();
398 DIType T(A.getElement(0));
401 DIType T(getFieldAs<DIType>(8));
405 /// isLocalToUnit - Return true if this subprogram is local to the current
406 /// compile unit, like 'static' in C.
407 unsigned isLocalToUnit() const { return getUnsignedField(9); }
408 unsigned isDefinition() const { return getUnsignedField(10); }
410 unsigned getVirtuality() const { return getUnsignedField(11); }
411 unsigned getVirtualIndex() const { return getUnsignedField(12); }
413 DICompositeType getContainingType() const {
414 return getFieldAs<DICompositeType>(13);
416 unsigned isArtificial() const { return getUnsignedField(14); }
417 unsigned isOptimized() const;
419 StringRef getFilename() const {
420 if (getVersion() == llvm::LLVMDebugVersion7)
421 return getCompileUnit().getFilename();
423 DIFile F = getFieldAs<DIFile>(6);
424 return F.getFilename();
427 StringRef getDirectory() const {
428 if (getVersion() == llvm::LLVMDebugVersion7)
429 return getCompileUnit().getFilename();
431 DIFile F = getFieldAs<DIFile>(6);
432 return F.getDirectory();
435 /// Verify - Verify that a subprogram descriptor is well formed.
438 /// print - print subprogram.
439 void print(raw_ostream &OS) const;
441 /// dump - print subprogram to dbgs() with a newline.
444 /// describes - Return true if this subprogram provides debugging
445 /// information for the function F.
446 bool describes(const Function *F);
449 /// DIGlobalVariable - This is a wrapper for a global variable.
450 class DIGlobalVariable : public DIGlobal {
452 explicit DIGlobalVariable(const MDNode *N = 0) : DIGlobal(N) {}
454 GlobalVariable *getGlobal() const { return getGlobalVariableField(11); }
456 /// Verify - Verify that a global variable descriptor is well formed.
459 /// print - print global variable.
460 void print(raw_ostream &OS) const;
462 /// dump - print global variable to dbgs() with a newline.
466 /// DIVariable - This is a wrapper for a variable (e.g. parameter, local,
468 class DIVariable : public DIDescriptor {
470 explicit DIVariable(const MDNode *N = 0)
473 DIScope getContext() const { return getFieldAs<DIScope>(1); }
474 StringRef getName() const { return getStringField(2); }
475 DICompileUnit getCompileUnit() const{
476 if (getVersion() == llvm::LLVMDebugVersion7)
477 return getFieldAs<DICompileUnit>(3);
479 DIFile F = getFieldAs<DIFile>(3);
480 return F.getCompileUnit();
482 unsigned getLineNumber() const { return getUnsignedField(4); }
483 DIType getType() const { return getFieldAs<DIType>(5); }
486 /// Verify - Verify that a variable descriptor is well formed.
489 /// HasComplexAddr - Return true if the variable has a complex address.
490 bool hasComplexAddress() const {
491 return getNumAddrElements() > 0;
494 unsigned getNumAddrElements() const;
496 uint64_t getAddrElement(unsigned Idx) const {
497 return getUInt64Field(Idx+6);
500 /// isBlockByrefVariable - Return true if the variable was declared as
501 /// a "__block" variable (Apple Blocks).
502 bool isBlockByrefVariable() const {
503 return getType().isBlockByrefStruct();
506 /// isInlinedFnArgument - Return trule if this variable provides debugging
507 /// information for an inlined function arguments.
508 bool isInlinedFnArgument(const Function *CurFn);
510 /// print - print variable.
511 void print(raw_ostream &OS) const;
513 /// dump - print variable to dbgs() with a newline.
517 /// DILexicalBlock - This is a wrapper for a lexical block.
518 class DILexicalBlock : public DIScope {
520 explicit DILexicalBlock(const MDNode *N = 0) : DIScope(N) {}
521 DIScope getContext() const { return getFieldAs<DIScope>(1); }
522 StringRef getDirectory() const { return getContext().getDirectory(); }
523 StringRef getFilename() const { return getContext().getFilename(); }
524 unsigned getLineNumber() const { return getUnsignedField(2); }
525 unsigned getColumnNumber() const { return getUnsignedField(3); }
528 /// DINameSpace - A wrapper for a C++ style name space.
529 class DINameSpace : public DIScope {
531 explicit DINameSpace(const MDNode *N = 0) : DIScope(N) {}
532 DIScope getContext() const { return getFieldAs<DIScope>(1); }
533 StringRef getName() const { return getStringField(2); }
534 StringRef getDirectory() const { return getContext().getDirectory(); }
535 StringRef getFilename() const { return getContext().getFilename(); }
536 DICompileUnit getCompileUnit() const{
537 if (getVersion() == llvm::LLVMDebugVersion7)
538 return getFieldAs<DICompileUnit>(3);
540 DIFile F = getFieldAs<DIFile>(3);
541 return F.getCompileUnit();
543 unsigned getLineNumber() const { return getUnsignedField(4); }
546 /// DILocation - This object holds location information. This object
547 /// is not associated with any DWARF tag.
548 class DILocation : public DIDescriptor {
550 explicit DILocation(const MDNode *N) : DIDescriptor(N) { }
552 unsigned getLineNumber() const { return getUnsignedField(0); }
553 unsigned getColumnNumber() const { return getUnsignedField(1); }
554 DIScope getScope() const { return getFieldAs<DIScope>(2); }
555 DILocation getOrigLocation() const { return getFieldAs<DILocation>(3); }
556 StringRef getFilename() const { return getScope().getFilename(); }
557 StringRef getDirectory() const { return getScope().getDirectory(); }
561 /// DIFactory - This object assists with the construction of the various
565 LLVMContext& VMContext;
567 Function *DeclareFn; // llvm.dbg.declare
568 Function *ValueFn; // llvm.dbg.value
570 DIFactory(const DIFactory &); // DO NOT IMPLEMENT
571 void operator=(const DIFactory&); // DO NOT IMPLEMENT
573 enum ComplexAddrKind { OpPlus=1, OpDeref };
575 explicit DIFactory(Module &m);
577 /// GetOrCreateArray - Create an descriptor for an array of descriptors.
578 /// This implicitly uniques the arrays created.
579 DIArray GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys);
581 /// GetOrCreateSubrange - Create a descriptor for a value range. This
582 /// implicitly uniques the values returned.
583 DISubrange GetOrCreateSubrange(int64_t Lo, int64_t Hi);
585 /// CreateCompileUnit - Create a new descriptor for the specified compile
587 DICompileUnit CreateCompileUnit(unsigned LangID,
592 bool isOptimized = false,
593 StringRef Flags = "",
594 unsigned RunTimeVer = 0);
596 /// CreateFile - Create a new descriptor for the specified file.
597 DIFile CreateFile(StringRef Filename, StringRef Directory, DICompileUnit CU);
599 /// CreateEnumerator - Create a single enumerator value.
600 DIEnumerator CreateEnumerator(StringRef Name, uint64_t Val);
602 /// CreateBasicType - Create a basic type like int, float, etc.
603 DIBasicType CreateBasicType(DIDescriptor Context, StringRef Name,
604 DIFile F, unsigned LineNumber,
605 uint64_t SizeInBits, uint64_t AlignInBits,
606 uint64_t OffsetInBits, unsigned Flags,
609 /// CreateBasicType - Create a basic type like int, float, etc.
610 DIBasicType CreateBasicTypeEx(DIDescriptor Context, StringRef Name,
611 DIFile F, unsigned LineNumber,
612 Constant *SizeInBits, Constant *AlignInBits,
613 Constant *OffsetInBits, unsigned Flags,
616 /// CreateDerivedType - Create a derived type like const qualified type,
617 /// pointer, typedef, etc.
618 DIDerivedType CreateDerivedType(unsigned Tag, DIDescriptor Context,
622 uint64_t SizeInBits, uint64_t AlignInBits,
623 uint64_t OffsetInBits, unsigned Flags,
626 /// CreateDerivedType - Create a derived type like const qualified type,
627 /// pointer, typedef, etc.
628 DIDerivedType CreateDerivedTypeEx(unsigned Tag, DIDescriptor Context,
632 Constant *SizeInBits,
633 Constant *AlignInBits,
634 Constant *OffsetInBits, unsigned Flags,
637 /// CreateCompositeType - Create a composite type like array, struct, etc.
638 DICompositeType CreateCompositeType(unsigned Tag, DIDescriptor Context,
643 uint64_t AlignInBits,
644 uint64_t OffsetInBits, unsigned Flags,
647 unsigned RunTimeLang = 0,
648 MDNode *ContainingType = 0);
650 /// CreateArtificialType - Create a new DIType with "artificial" flag set.
651 DIType CreateArtificialType(DIType Ty);
653 /// CreateCompositeType - Create a composite type like array, struct, etc.
654 DICompositeType CreateCompositeTypeEx(unsigned Tag, DIDescriptor Context,
658 Constant *SizeInBits,
659 Constant *AlignInBits,
660 Constant *OffsetInBits,
664 unsigned RunTimeLang = 0);
666 /// CreateSubprogram - Create a new descriptor for the specified subprogram.
667 /// See comments in DISubprogram for descriptions of these fields.
668 DISubprogram CreateSubprogram(DIDescriptor Context, StringRef Name,
669 StringRef DisplayName,
670 StringRef LinkageName,
671 DIFile F, unsigned LineNo,
672 DIType Ty, bool isLocalToUnit,
677 bool isArtificial = 0,
678 bool isOptimized = false);
680 /// CreateSubprogramDefinition - Create new subprogram descriptor for the
681 /// given declaration.
682 DISubprogram CreateSubprogramDefinition(DISubprogram &SPDeclaration);
684 /// CreateGlobalVariable - Create a new descriptor for the specified global.
686 CreateGlobalVariable(DIDescriptor Context, StringRef Name,
687 StringRef DisplayName,
688 StringRef LinkageName,
690 unsigned LineNo, DIType Ty, bool isLocalToUnit,
691 bool isDefinition, llvm::GlobalVariable *GV);
693 /// CreateVariable - Create a new descriptor for the specified variable.
694 DIVariable CreateVariable(unsigned Tag, DIDescriptor Context,
696 DIFile F, unsigned LineNo,
699 /// CreateComplexVariable - Create a new descriptor for the specified
700 /// variable which has a complex address expression for its address.
701 DIVariable CreateComplexVariable(unsigned Tag, DIDescriptor Context,
702 const std::string &Name,
703 DIFile F, unsigned LineNo,
705 SmallVector<Value *, 9> &addr);
707 /// CreateLexicalBlock - This creates a descriptor for a lexical block
708 /// with the specified parent context.
709 DILexicalBlock CreateLexicalBlock(DIDescriptor Context, unsigned Line = 0,
712 /// CreateNameSpace - This creates new descriptor for a namespace
713 /// with the specified parent context.
714 DINameSpace CreateNameSpace(DIDescriptor Context, StringRef Name,
715 DIFile F, unsigned LineNo);
717 /// CreateLocation - Creates a debug info location.
718 DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
719 DIScope S, DILocation OrigLoc);
721 /// CreateLocation - Creates a debug info location.
722 DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
723 DIScope S, MDNode *OrigLoc = 0);
725 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
726 Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
727 BasicBlock *InsertAtEnd);
729 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
730 Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
731 Instruction *InsertBefore);
733 /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
734 Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
735 DIVariable D, BasicBlock *InsertAtEnd);
737 /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
738 Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
739 DIVariable D, Instruction *InsertBefore);
741 Constant *GetTagConstant(unsigned TAG);
744 bool getLocationInfo(const Value *V, std::string &DisplayName,
745 std::string &Type, unsigned &LineNo, std::string &File,
748 /// getDISubprogram - Find subprogram that is enclosing this scope.
749 DISubprogram getDISubprogram(const MDNode *Scope);
751 /// getDICompositeType - Find underlying composite type.
752 DICompositeType getDICompositeType(DIType T);
754 class DebugInfoFinder {
756 /// processModule - Process entire module and collect debug info
758 void processModule(Module &M);
761 /// processType - Process DIType.
762 void processType(DIType DT);
764 /// processLexicalBlock - Process DILexicalBlock.
765 void processLexicalBlock(DILexicalBlock LB);
767 /// processSubprogram - Process DISubprogram.
768 void processSubprogram(DISubprogram SP);
770 /// processDeclare - Process DbgDeclareInst.
771 void processDeclare(DbgDeclareInst *DDI);
773 /// processLocation - Process DILocation.
774 void processLocation(DILocation Loc);
776 /// addCompileUnit - Add compile unit into CUs.
777 bool addCompileUnit(DICompileUnit CU);
779 /// addGlobalVariable - Add global variable into GVs.
780 bool addGlobalVariable(DIGlobalVariable DIG);
782 // addSubprogram - Add subprgoram into SPs.
783 bool addSubprogram(DISubprogram SP);
785 /// addType - Add type into Tys.
786 bool addType(DIType DT);
789 typedef SmallVector<MDNode *, 8>::const_iterator iterator;
790 iterator compile_unit_begin() const { return CUs.begin(); }
791 iterator compile_unit_end() const { return CUs.end(); }
792 iterator subprogram_begin() const { return SPs.begin(); }
793 iterator subprogram_end() const { return SPs.end(); }
794 iterator global_variable_begin() const { return GVs.begin(); }
795 iterator global_variable_end() const { return GVs.end(); }
796 iterator type_begin() const { return TYs.begin(); }
797 iterator type_end() const { return TYs.end(); }
799 unsigned compile_unit_count() const { return CUs.size(); }
800 unsigned global_variable_count() const { return GVs.size(); }
801 unsigned subprogram_count() const { return SPs.size(); }
802 unsigned type_count() const { return TYs.size(); }
805 SmallVector<MDNode *, 8> CUs; // Compile Units
806 SmallVector<MDNode *, 8> SPs; // Subprograms
807 SmallVector<MDNode *, 8> GVs; // Global Variables;
808 SmallVector<MDNode *, 8> TYs; // Types
809 SmallPtrSet<MDNode *, 64> NodesSeen;
811 } // end namespace llvm