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"
35 struct DebugLocTracker;
40 /// DIDescriptor - A thin wraper around MDNode to access encoded debug info.
41 /// This should not be stored in a container, because underly MDNode may
42 /// change in certain situations.
47 /// DIDescriptor constructor. If the specified node is non-null, check
48 /// to make sure that the tag in the descriptor matches 'RequiredTag'. If
49 /// not, the debug info is corrupt and we ignore it.
50 DIDescriptor(MDNode *N, unsigned RequiredTag);
52 StringRef getStringField(unsigned Elt) const;
53 unsigned getUnsignedField(unsigned Elt) const {
54 return (unsigned)getUInt64Field(Elt);
56 uint64_t getUInt64Field(unsigned Elt) const;
57 DIDescriptor getDescriptorField(unsigned Elt) const;
59 template <typename DescTy>
60 DescTy getFieldAs(unsigned Elt) const {
61 return DescTy(getDescriptorField(Elt).getNode());
64 GlobalVariable *getGlobalVariableField(unsigned Elt) const;
67 explicit DIDescriptor() : DbgNode(0) {}
68 explicit DIDescriptor(MDNode *N) : DbgNode(N) {}
70 bool isNull() const { return DbgNode == 0; }
72 MDNode *getNode() const { return DbgNode; }
74 unsigned getVersion() const {
75 return getUnsignedField(0) & LLVMDebugVersionMask;
78 unsigned getTag() const {
79 return getUnsignedField(0) & ~LLVMDebugVersionMask;
82 /// ValidDebugInfo - Return true if N represents valid debug info value.
83 static bool ValidDebugInfo(MDNode *N, unsigned OptLevel);
85 /// dump - print descriptor.
88 bool isDerivedType() const;
89 bool isCompositeType() const;
90 bool isBasicType() const;
91 bool isVariable() const;
92 bool isSubprogram() const;
93 bool isGlobalVariable() const;
95 bool isCompileUnit() const;
96 bool isNameSpace() const;
97 bool isLexicalBlock() const;
98 bool isSubrange() const;
99 bool isEnumerator() const;
101 bool isGlobal() const;
104 /// DISubrange - This is used to represent ranges, for array bounds.
105 class DISubrange : public DIDescriptor {
107 explicit DISubrange(MDNode *N = 0)
108 : DIDescriptor(N, dwarf::DW_TAG_subrange_type) {}
110 int64_t getLo() const { return (int64_t)getUInt64Field(1); }
111 int64_t getHi() const { return (int64_t)getUInt64Field(2); }
114 /// DIArray - This descriptor holds an array of descriptors.
115 class DIArray : public DIDescriptor {
117 explicit DIArray(MDNode *N = 0)
120 unsigned getNumElements() const;
121 DIDescriptor getElement(unsigned Idx) const {
122 return getDescriptorField(Idx);
126 /// DIScope - A base class for various scopes.
127 class DIScope : public DIDescriptor {
129 explicit DIScope(MDNode *N = 0) : DIDescriptor (N) {
130 if (DbgNode && !isScope())
133 virtual ~DIScope() {}
135 StringRef getFilename() const;
136 StringRef getDirectory() const;
139 /// DICompileUnit - A wrapper for a compile unit.
140 class DICompileUnit : public DIScope {
142 explicit DICompileUnit(MDNode *N = 0) : DIScope(N) {
143 if (DbgNode && !isCompileUnit())
147 unsigned getLanguage() const { return getUnsignedField(2); }
148 StringRef getFilename() const { return getStringField(3); }
149 StringRef getDirectory() const { return getStringField(4); }
150 StringRef getProducer() const { return getStringField(5); }
152 /// isMain - Each input file is encoded as a separate compile unit in LLVM
153 /// debugging information output. However, many target specific tool chains
154 /// prefer to encode only one compile unit in an object file. In this
155 /// situation, the LLVM code generator will include debugging information
156 /// entities in the compile unit that is marked as main compile unit. The
157 /// code generator accepts maximum one main compile unit per module. If a
158 /// module does not contain any main compile unit then the code generator
159 /// will emit multiple compile units in the output object file.
161 bool isMain() const { return getUnsignedField(6); }
162 bool isOptimized() const { return getUnsignedField(7); }
163 StringRef getFlags() const { return getStringField(8); }
164 unsigned getRunTimeVersion() const { return getUnsignedField(9); }
166 /// Verify - Verify that a compile unit is well formed.
169 /// dump - print compile unit.
173 /// DIEnumerator - A wrapper for an enumerator (e.g. X and Y in 'enum {X,Y}').
174 /// FIXME: it seems strange that this doesn't have either a reference to the
175 /// type/precision or a file/line pair for location info.
176 class DIEnumerator : public DIDescriptor {
178 explicit DIEnumerator(MDNode *N = 0)
179 : DIDescriptor(N, dwarf::DW_TAG_enumerator) {}
181 StringRef getName() const { return getStringField(1); }
182 uint64_t getEnumValue() const { return getUInt64Field(2); }
185 /// DIType - This is a wrapper for a type.
186 /// FIXME: Types should be factored much better so that CV qualifiers and
187 /// others do not require a huge and empty descriptor full of zeros.
188 class DIType : public DIDescriptor {
191 FlagPrivate = 1 << 0,
192 FlagProtected = 1 << 1,
193 FlagFwdDecl = 1 << 2,
194 FlagAppleBlock = 1 << 3,
195 FlagBlockByrefStruct = 1 << 4,
200 DIType(MDNode *N, unsigned Tag)
201 : DIDescriptor(N, Tag) {}
202 // This ctor is used when the Tag has already been validated by a derived
204 DIType(MDNode *N, bool, bool) : DIDescriptor(N) {}
208 /// Verify - Verify that a type descriptor is well formed.
211 explicit DIType(MDNode *N);
215 DIDescriptor getContext() const { return getDescriptorField(1); }
216 StringRef getName() const { return getStringField(2); }
217 DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
218 unsigned getLineNumber() const { return getUnsignedField(4); }
219 uint64_t getSizeInBits() const { return getUInt64Field(5); }
220 uint64_t getAlignInBits() const { return getUInt64Field(6); }
221 // FIXME: Offset is only used for DW_TAG_member nodes. Making every type
222 // carry this is just plain insane.
223 uint64_t getOffsetInBits() const { return getUInt64Field(7); }
224 unsigned getFlags() const { return getUnsignedField(8); }
225 bool isPrivate() const {
226 return (getFlags() & FlagPrivate) != 0;
228 bool isProtected() const {
229 return (getFlags() & FlagProtected) != 0;
231 bool isForwardDecl() const {
232 return (getFlags() & FlagFwdDecl) != 0;
234 // isAppleBlock - Return true if this is the Apple Blocks extension.
235 bool isAppleBlockExtension() const {
236 return (getFlags() & FlagAppleBlock) != 0;
238 bool isBlockByrefStruct() const {
239 return (getFlags() & FlagBlockByrefStruct) != 0;
241 bool isVirtual() const {
242 return (getFlags() & FlagVirtual) != 0;
245 /// dump - print type.
249 /// DIBasicType - A basic type, like 'int' or 'float'.
250 class DIBasicType : public DIType {
252 explicit DIBasicType(MDNode *N = 0)
253 : DIType(N, dwarf::DW_TAG_base_type) {}
255 unsigned getEncoding() const { return getUnsignedField(9); }
257 /// dump - print basic type.
261 /// DIDerivedType - A simple derived type, like a const qualified type,
262 /// a typedef, a pointer or reference, etc.
263 class DIDerivedType : public DIType {
265 explicit DIDerivedType(MDNode *N, bool, bool)
266 : DIType(N, true, true) {}
268 explicit DIDerivedType(MDNode *N = 0)
269 : DIType(N, true, true) {
270 if (DbgNode && !isDerivedType())
274 DIType getTypeDerivedFrom() const { return getFieldAs<DIType>(9); }
276 /// getOriginalTypeSize - If this type is derived from a base type then
277 /// return base type size.
278 uint64_t getOriginalTypeSize() const;
279 /// dump - print derived type.
282 /// replaceAllUsesWith - Replace all uses of debug info referenced by
283 /// this descriptor. After this completes, the current debug info value
285 void replaceAllUsesWith(DIDescriptor &D);
288 /// DICompositeType - This descriptor holds a type that can refer to multiple
289 /// other types, like a function or struct.
290 /// FIXME: Why is this a DIDerivedType??
291 class DICompositeType : public DIDerivedType {
293 explicit DICompositeType(MDNode *N = 0)
294 : DIDerivedType(N, true, true) {
295 if (N && !isCompositeType())
299 DIArray getTypeArray() const { return getFieldAs<DIArray>(10); }
300 unsigned getRunTimeLang() const { return getUnsignedField(11); }
302 /// Verify - Verify that a composite type descriptor is well formed.
305 /// dump - print composite type.
309 /// DIGlobal - This is a common class for global variables and subprograms.
310 class DIGlobal : public DIDescriptor {
312 explicit DIGlobal(MDNode *N, unsigned RequiredTag)
313 : DIDescriptor(N, RequiredTag) {}
316 virtual ~DIGlobal() {}
318 DIDescriptor getContext() const { return getDescriptorField(2); }
319 StringRef getName() const { return getStringField(3); }
320 StringRef getDisplayName() const { return getStringField(4); }
321 StringRef getLinkageName() const { return getStringField(5); }
322 DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(6); }
323 unsigned getLineNumber() const { return getUnsignedField(7); }
324 DIType getType() const { return getFieldAs<DIType>(8); }
326 /// isLocalToUnit - Return true if this subprogram is local to the current
327 /// compile unit, like 'static' in C.
328 unsigned isLocalToUnit() const { return getUnsignedField(9); }
329 unsigned isDefinition() const { return getUnsignedField(10); }
331 /// dump - print global.
335 /// DISubprogram - This is a wrapper for a subprogram (e.g. a function).
336 class DISubprogram : public DIScope {
338 explicit DISubprogram(MDNode *N = 0) : DIScope(N) {
339 if (DbgNode && !isSubprogram())
343 DIDescriptor getContext() const { return getDescriptorField(2); }
344 StringRef getName() const { return getStringField(3); }
345 StringRef getDisplayName() const { return getStringField(4); }
346 StringRef getLinkageName() const { return getStringField(5); }
347 DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(6); }
348 unsigned getLineNumber() const { return getUnsignedField(7); }
349 DICompositeType getType() const { return getFieldAs<DICompositeType>(8); }
351 /// getReturnTypeName - Subprogram return types are encoded either as
352 /// DIType or as DICompositeType.
353 StringRef getReturnTypeName() const {
354 DICompositeType DCT(getFieldAs<DICompositeType>(8));
356 DIArray A = DCT.getTypeArray();
357 DIType T(A.getElement(0).getNode());
360 DIType T(getFieldAs<DIType>(8));
364 /// isLocalToUnit - Return true if this subprogram is local to the current
365 /// compile unit, like 'static' in C.
366 unsigned isLocalToUnit() const { return getUnsignedField(9); }
367 unsigned isDefinition() const { return getUnsignedField(10); }
369 unsigned getVirtuality() const { return getUnsignedField(11); }
370 unsigned getVirtualIndex() const { return getUnsignedField(12); }
372 DICompositeType getContainingType() const {
373 return getFieldAs<DICompositeType>(13);
376 StringRef getFilename() const { return getCompileUnit().getFilename();}
377 StringRef getDirectory() const { return getCompileUnit().getDirectory();}
379 /// Verify - Verify that a subprogram descriptor is well formed.
382 /// dump - print subprogram.
385 /// describes - Return true if this subprogram provides debugging
386 /// information for the function F.
387 bool describes(const Function *F);
390 /// DIGlobalVariable - This is a wrapper for a global variable.
391 class DIGlobalVariable : public DIGlobal {
393 explicit DIGlobalVariable(MDNode *N = 0)
394 : DIGlobal(N, dwarf::DW_TAG_variable) {}
396 GlobalVariable *getGlobal() const { return getGlobalVariableField(11); }
398 /// Verify - Verify that a global variable descriptor is well formed.
401 /// dump - print global variable.
405 /// DIVariable - This is a wrapper for a variable (e.g. parameter, local,
407 class DIVariable : public DIDescriptor {
409 explicit DIVariable(MDNode *N = 0)
411 if (DbgNode && !isVariable())
415 DIDescriptor getContext() const { return getDescriptorField(1); }
416 StringRef getName() const { return getStringField(2); }
417 DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
418 unsigned getLineNumber() const { return getUnsignedField(4); }
419 DIType getType() const { return getFieldAs<DIType>(5); }
422 /// Verify - Verify that a variable descriptor is well formed.
425 /// HasComplexAddr - Return true if the variable has a complex address.
426 bool hasComplexAddress() const {
427 return getNumAddrElements() > 0;
430 unsigned getNumAddrElements() const;
432 uint64_t getAddrElement(unsigned Idx) const {
433 return getUInt64Field(Idx+6);
436 /// isBlockByrefVariable - Return true if the variable was declared as
437 /// a "__block" variable (Apple Blocks).
438 bool isBlockByrefVariable() const {
439 return getType().isBlockByrefStruct();
442 /// dump - print variable.
446 /// DILexicalBlock - This is a wrapper for a lexical block.
447 class DILexicalBlock : public DIScope {
449 explicit DILexicalBlock(MDNode *N = 0) : DIScope(N) {
450 if (DbgNode && !isLexicalBlock())
453 DIScope getContext() const { return getFieldAs<DIScope>(1); }
454 StringRef getDirectory() const { return getContext().getDirectory(); }
455 StringRef getFilename() const { return getContext().getFilename(); }
458 /// DINameSpace - A wrapper for a C++ style name space.
459 class DINameSpace : public DIScope {
461 explicit DINameSpace(MDNode *N = 0) : DIScope(N) {
462 if (DbgNode && !isNameSpace())
466 DIScope getContext() const { return getFieldAs<DIScope>(1); }
467 StringRef getName() const { return getStringField(2); }
468 StringRef getDirectory() const { return getContext().getDirectory(); }
469 StringRef getFilename() const { return getContext().getFilename(); }
470 DICompileUnit getCompileUnit() const { return getFieldAs<DICompileUnit>(3);}
471 unsigned getLineNumber() const { return getUnsignedField(4); }
474 /// DILocation - This object holds location information. This object
475 /// is not associated with any DWARF tag.
476 class DILocation : public DIDescriptor {
478 explicit DILocation(MDNode *N) : DIDescriptor(N) { ; }
480 unsigned getLineNumber() const { return getUnsignedField(0); }
481 unsigned getColumnNumber() const { return getUnsignedField(1); }
482 DIScope getScope() const { return getFieldAs<DIScope>(2); }
483 DILocation getOrigLocation() const { return getFieldAs<DILocation>(3); }
484 StringRef getFilename() const { return getScope().getFilename(); }
485 StringRef getDirectory() const { return getScope().getDirectory(); }
488 /// DIFactory - This object assists with the construction of the various
492 LLVMContext& VMContext;
494 const Type *EmptyStructPtr; // "{}*".
495 Function *DeclareFn; // llvm.dbg.declare
496 Function *ValueFn; // llvm.dbg.value
498 DIFactory(const DIFactory &); // DO NOT IMPLEMENT
499 void operator=(const DIFactory&); // DO NOT IMPLEMENT
501 enum ComplexAddrKind { OpPlus=1, OpDeref };
503 explicit DIFactory(Module &m);
505 /// GetOrCreateArray - Create an descriptor for an array of descriptors.
506 /// This implicitly uniques the arrays created.
507 DIArray GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys);
509 /// GetOrCreateSubrange - Create a descriptor for a value range. This
510 /// implicitly uniques the values returned.
511 DISubrange GetOrCreateSubrange(int64_t Lo, int64_t Hi);
513 /// CreateCompileUnit - Create a new descriptor for the specified compile
515 DICompileUnit CreateCompileUnit(unsigned LangID,
520 bool isOptimized = false,
521 StringRef Flags = "",
522 unsigned RunTimeVer = 0);
524 /// CreateEnumerator - Create a single enumerator value.
525 DIEnumerator CreateEnumerator(StringRef Name, uint64_t Val);
527 /// CreateBasicType - Create a basic type like int, float, etc.
528 DIBasicType CreateBasicType(DIDescriptor Context, StringRef Name,
529 DICompileUnit CompileUnit, unsigned LineNumber,
530 uint64_t SizeInBits, uint64_t AlignInBits,
531 uint64_t OffsetInBits, unsigned Flags,
534 /// CreateBasicType - Create a basic type like int, float, etc.
535 DIBasicType CreateBasicTypeEx(DIDescriptor Context, StringRef Name,
536 DICompileUnit CompileUnit, unsigned LineNumber,
537 Constant *SizeInBits, Constant *AlignInBits,
538 Constant *OffsetInBits, unsigned Flags,
541 /// CreateDerivedType - Create a derived type like const qualified type,
542 /// pointer, typedef, etc.
543 DIDerivedType CreateDerivedType(unsigned Tag, DIDescriptor Context,
545 DICompileUnit CompileUnit,
547 uint64_t SizeInBits, uint64_t AlignInBits,
548 uint64_t OffsetInBits, unsigned Flags,
551 /// CreateDerivedType - Create a derived type like const qualified type,
552 /// pointer, typedef, etc.
553 DIDerivedType CreateDerivedTypeEx(unsigned Tag, DIDescriptor Context,
555 DICompileUnit CompileUnit,
557 Constant *SizeInBits, Constant *AlignInBits,
558 Constant *OffsetInBits, unsigned Flags,
561 /// CreateCompositeType - Create a composite type like array, struct, etc.
562 DICompositeType CreateCompositeType(unsigned Tag, DIDescriptor Context,
564 DICompileUnit CompileUnit,
567 uint64_t AlignInBits,
568 uint64_t OffsetInBits, unsigned Flags,
571 unsigned RunTimeLang = 0);
573 /// CreateCompositeType - Create a composite type like array, struct, etc.
574 DICompositeType CreateCompositeTypeEx(unsigned Tag, DIDescriptor Context,
576 DICompileUnit CompileUnit,
578 Constant *SizeInBits,
579 Constant *AlignInBits,
580 Constant *OffsetInBits, unsigned Flags,
583 unsigned RunTimeLang = 0);
585 /// CreateSubprogram - Create a new descriptor for the specified subprogram.
586 /// See comments in DISubprogram for descriptions of these fields.
587 DISubprogram CreateSubprogram(DIDescriptor Context, StringRef Name,
588 StringRef DisplayName,
589 StringRef LinkageName,
590 DICompileUnit CompileUnit, unsigned LineNo,
591 DIType Type, bool isLocalToUnit,
597 /// CreateSubprogramDefinition - Create new subprogram descriptor for the
598 /// given declaration.
599 DISubprogram CreateSubprogramDefinition(DISubprogram &SPDeclaration);
601 /// CreateGlobalVariable - Create a new descriptor for the specified global.
603 CreateGlobalVariable(DIDescriptor Context, StringRef Name,
604 StringRef DisplayName,
605 StringRef LinkageName,
606 DICompileUnit CompileUnit,
607 unsigned LineNo, DIType Type, bool isLocalToUnit,
608 bool isDefinition, llvm::GlobalVariable *GV);
610 /// CreateVariable - Create a new descriptor for the specified variable.
611 DIVariable CreateVariable(unsigned Tag, DIDescriptor Context,
613 DICompileUnit CompileUnit, unsigned LineNo,
616 /// CreateComplexVariable - Create a new descriptor for the specified
617 /// variable which has a complex address expression for its address.
618 DIVariable CreateComplexVariable(unsigned Tag, DIDescriptor Context,
619 const std::string &Name,
620 DICompileUnit CompileUnit, unsigned LineNo,
622 SmallVector<Value *, 9> &addr);
624 /// CreateLexicalBlock - This creates a descriptor for a lexical block
625 /// with the specified parent context.
626 DILexicalBlock CreateLexicalBlock(DIDescriptor Context);
628 /// CreateNameSpace - This creates new descriptor for a namespace
629 /// with the specified parent context.
630 DINameSpace CreateNameSpace(DIDescriptor Context, StringRef Name,
631 DICompileUnit CU, unsigned LineNo);
633 /// CreateLocation - Creates a debug info location.
634 DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
635 DIScope S, DILocation OrigLoc);
637 /// CreateLocation - Creates a debug info location.
638 DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
639 DIScope S, MDNode *OrigLoc = 0);
641 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
642 Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
643 BasicBlock *InsertAtEnd);
645 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
646 Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
647 Instruction *InsertBefore);
649 /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
650 Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
651 DIVariable D, BasicBlock *InsertAtEnd);
653 /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
654 Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
655 DIVariable D, Instruction *InsertBefore);
657 Constant *GetTagConstant(unsigned TAG);
660 /// Finds the dbg.declare intrinsic corresponding to this value if any.
661 /// It looks through pointer casts too.
662 const DbgDeclareInst *findDbgDeclare(const Value *V, bool stripCasts = true);
664 /// Find the debug info descriptor corresponding to this global variable.
665 Value *findDbgGlobalDeclare(GlobalVariable *V);
667 bool getLocationInfo(const Value *V, std::string &DisplayName,
668 std::string &Type, unsigned &LineNo, std::string &File,
671 /// ExtractDebugLocation - Extract debug location information
673 DebugLoc ExtractDebugLocation(DILocation &Loc,
674 DebugLocTracker &DebugLocInfo);
676 /// getDISubprogram - Find subprogram that is enclosing this scope.
677 DISubprogram getDISubprogram(MDNode *Scope);
679 /// getDICompositeType - Find underlying composite type.
680 DICompositeType getDICompositeType(DIType T);
682 class DebugInfoFinder {
684 /// processModule - Process entire module and collect debug info
686 void processModule(Module &M);
689 /// processType - Process DIType.
690 void processType(DIType DT);
692 /// processLexicalBlock - Process DILexicalBlock.
693 void processLexicalBlock(DILexicalBlock LB);
695 /// processSubprogram - Process DISubprogram.
696 void processSubprogram(DISubprogram SP);
698 /// processDeclare - Process DbgDeclareInst.
699 void processDeclare(DbgDeclareInst *DDI);
701 /// processLocation - Process DILocation.
702 void processLocation(DILocation Loc);
704 /// addCompileUnit - Add compile unit into CUs.
705 bool addCompileUnit(DICompileUnit CU);
707 /// addGlobalVariable - Add global variable into GVs.
708 bool addGlobalVariable(DIGlobalVariable DIG);
710 // addSubprogram - Add subprgoram into SPs.
711 bool addSubprogram(DISubprogram SP);
713 /// addType - Add type into Tys.
714 bool addType(DIType DT);
717 typedef SmallVector<MDNode *, 8>::iterator iterator;
718 iterator compile_unit_begin() { return CUs.begin(); }
719 iterator compile_unit_end() { return CUs.end(); }
720 iterator subprogram_begin() { return SPs.begin(); }
721 iterator subprogram_end() { return SPs.end(); }
722 iterator global_variable_begin() { return GVs.begin(); }
723 iterator global_variable_end() { return GVs.end(); }
724 iterator type_begin() { return TYs.begin(); }
725 iterator type_end() { return TYs.end(); }
727 unsigned compile_unit_count() { return CUs.size(); }
728 unsigned global_variable_count() { return GVs.size(); }
729 unsigned subprogram_count() { return SPs.size(); }
730 unsigned type_count() { return TYs.size(); }
733 SmallVector<MDNode *, 8> CUs; // Compile Units
734 SmallVector<MDNode *, 8> SPs; // Subprograms
735 SmallVector<MDNode *, 8> GVs; // Global Variables;
736 SmallVector<MDNode *, 8> TYs; // Types
737 SmallPtrSet<MDNode *, 64> NodesSeen;
739 } // end namespace llvm