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,
196 FlagVirtual = 1 << 5,
197 FlagArtificial = 1 << 6 // To identify artificial arguments in
198 // a subroutine type. e.g. "this" in c++.
202 DIType(MDNode *N, unsigned Tag)
203 : DIDescriptor(N, Tag) {}
204 // This ctor is used when the Tag has already been validated by a derived
206 DIType(MDNode *N, bool, bool) : DIDescriptor(N) {}
210 /// Verify - Verify that a type descriptor is well formed.
213 explicit DIType(MDNode *N);
217 DIDescriptor getContext() const { return getDescriptorField(1); }
218 StringRef getName() const { return getStringField(2); }
219 DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
220 unsigned getLineNumber() const { return getUnsignedField(4); }
221 uint64_t getSizeInBits() const { return getUInt64Field(5); }
222 uint64_t getAlignInBits() const { return getUInt64Field(6); }
223 // FIXME: Offset is only used for DW_TAG_member nodes. Making every type
224 // carry this is just plain insane.
225 uint64_t getOffsetInBits() const { return getUInt64Field(7); }
226 unsigned getFlags() const { return getUnsignedField(8); }
227 bool isPrivate() const {
228 return (getFlags() & FlagPrivate) != 0;
230 bool isProtected() const {
231 return (getFlags() & FlagProtected) != 0;
233 bool isForwardDecl() const {
234 return (getFlags() & FlagFwdDecl) != 0;
236 // isAppleBlock - Return true if this is the Apple Blocks extension.
237 bool isAppleBlockExtension() const {
238 return (getFlags() & FlagAppleBlock) != 0;
240 bool isBlockByrefStruct() const {
241 return (getFlags() & FlagBlockByrefStruct) != 0;
243 bool isVirtual() const {
244 return (getFlags() & FlagVirtual) != 0;
246 bool isArtificial() const {
247 return (getFlags() & FlagArtificial) != 0;
250 /// dump - print type.
254 /// DIBasicType - A basic type, like 'int' or 'float'.
255 class DIBasicType : public DIType {
257 explicit DIBasicType(MDNode *N = 0)
258 : DIType(N, dwarf::DW_TAG_base_type) {}
260 unsigned getEncoding() const { return getUnsignedField(9); }
262 /// dump - print basic type.
266 /// DIDerivedType - A simple derived type, like a const qualified type,
267 /// a typedef, a pointer or reference, etc.
268 class DIDerivedType : public DIType {
270 explicit DIDerivedType(MDNode *N, bool, bool)
271 : DIType(N, true, true) {}
273 explicit DIDerivedType(MDNode *N = 0)
274 : DIType(N, true, true) {
275 if (DbgNode && !isDerivedType())
279 DIType getTypeDerivedFrom() const { return getFieldAs<DIType>(9); }
281 /// getOriginalTypeSize - If this type is derived from a base type then
282 /// return base type size.
283 uint64_t getOriginalTypeSize() const;
284 /// dump - print derived type.
287 /// replaceAllUsesWith - Replace all uses of debug info referenced by
288 /// this descriptor. After this completes, the current debug info value
290 void replaceAllUsesWith(DIDescriptor &D);
293 /// DICompositeType - This descriptor holds a type that can refer to multiple
294 /// other types, like a function or struct.
295 /// FIXME: Why is this a DIDerivedType??
296 class DICompositeType : public DIDerivedType {
298 explicit DICompositeType(MDNode *N = 0)
299 : DIDerivedType(N, true, true) {
300 if (N && !isCompositeType())
304 DIArray getTypeArray() const { return getFieldAs<DIArray>(10); }
305 unsigned getRunTimeLang() const { return getUnsignedField(11); }
306 DICompositeType getContainingType() const {
307 return getFieldAs<DICompositeType>(12);
310 /// Verify - Verify that a composite type descriptor is well formed.
313 /// dump - print composite type.
317 /// DIGlobal - This is a common class for global variables and subprograms.
318 class DIGlobal : public DIDescriptor {
320 explicit DIGlobal(MDNode *N, unsigned RequiredTag)
321 : DIDescriptor(N, RequiredTag) {}
324 virtual ~DIGlobal() {}
326 DIDescriptor getContext() const { return getDescriptorField(2); }
327 StringRef getName() const { return getStringField(3); }
328 StringRef getDisplayName() const { return getStringField(4); }
329 StringRef getLinkageName() const { return getStringField(5); }
330 DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(6); }
331 unsigned getLineNumber() const { return getUnsignedField(7); }
332 DIType getType() const { return getFieldAs<DIType>(8); }
334 /// isLocalToUnit - Return true if this subprogram is local to the current
335 /// compile unit, like 'static' in C.
336 unsigned isLocalToUnit() const { return getUnsignedField(9); }
337 unsigned isDefinition() const { return getUnsignedField(10); }
339 /// dump - print global.
343 /// DISubprogram - This is a wrapper for a subprogram (e.g. a function).
344 class DISubprogram : public DIScope {
346 explicit DISubprogram(MDNode *N = 0) : DIScope(N) {
347 if (DbgNode && !isSubprogram())
351 DIDescriptor getContext() const { return getDescriptorField(2); }
352 StringRef getName() const { return getStringField(3); }
353 StringRef getDisplayName() const { return getStringField(4); }
354 StringRef getLinkageName() const { return getStringField(5); }
355 DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(6); }
356 unsigned getLineNumber() const { return getUnsignedField(7); }
357 DICompositeType getType() const { return getFieldAs<DICompositeType>(8); }
359 /// getReturnTypeName - Subprogram return types are encoded either as
360 /// DIType or as DICompositeType.
361 StringRef getReturnTypeName() const {
362 DICompositeType DCT(getFieldAs<DICompositeType>(8));
364 DIArray A = DCT.getTypeArray();
365 DIType T(A.getElement(0).getNode());
368 DIType T(getFieldAs<DIType>(8));
372 /// isLocalToUnit - Return true if this subprogram is local to the current
373 /// compile unit, like 'static' in C.
374 unsigned isLocalToUnit() const { return getUnsignedField(9); }
375 unsigned isDefinition() const { return getUnsignedField(10); }
377 unsigned getVirtuality() const { return getUnsignedField(11); }
378 unsigned getVirtualIndex() const { return getUnsignedField(12); }
380 DICompositeType getContainingType() const {
381 return getFieldAs<DICompositeType>(13);
383 unsigned isArtificial() const { return getUnsignedField(14); }
385 StringRef getFilename() const { return getCompileUnit().getFilename();}
386 StringRef getDirectory() const { return getCompileUnit().getDirectory();}
388 /// Verify - Verify that a subprogram descriptor is well formed.
391 /// dump - print subprogram.
394 /// describes - Return true if this subprogram provides debugging
395 /// information for the function F.
396 bool describes(const Function *F);
399 /// DIGlobalVariable - This is a wrapper for a global variable.
400 class DIGlobalVariable : public DIGlobal {
402 explicit DIGlobalVariable(MDNode *N = 0)
403 : DIGlobal(N, dwarf::DW_TAG_variable) {}
405 GlobalVariable *getGlobal() const { return getGlobalVariableField(11); }
407 /// Verify - Verify that a global variable descriptor is well formed.
410 /// dump - print global variable.
414 /// DIVariable - This is a wrapper for a variable (e.g. parameter, local,
416 class DIVariable : public DIDescriptor {
418 explicit DIVariable(MDNode *N = 0)
420 if (DbgNode && !isVariable())
424 DIDescriptor getContext() const { return getDescriptorField(1); }
425 StringRef getName() const { return getStringField(2); }
426 DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
427 unsigned getLineNumber() const { return getUnsignedField(4); }
428 DIType getType() const { return getFieldAs<DIType>(5); }
431 /// Verify - Verify that a variable descriptor is well formed.
434 /// HasComplexAddr - Return true if the variable has a complex address.
435 bool hasComplexAddress() const {
436 return getNumAddrElements() > 0;
439 unsigned getNumAddrElements() const;
441 uint64_t getAddrElement(unsigned Idx) const {
442 return getUInt64Field(Idx+6);
445 /// isBlockByrefVariable - Return true if the variable was declared as
446 /// a "__block" variable (Apple Blocks).
447 bool isBlockByrefVariable() const {
448 return getType().isBlockByrefStruct();
451 /// dump - print variable.
455 /// DILexicalBlock - This is a wrapper for a lexical block.
456 class DILexicalBlock : public DIScope {
458 explicit DILexicalBlock(MDNode *N = 0) : DIScope(N) {
459 if (DbgNode && !isLexicalBlock())
462 DIScope getContext() const { return getFieldAs<DIScope>(1); }
463 StringRef getDirectory() const { return getContext().getDirectory(); }
464 StringRef getFilename() const { return getContext().getFilename(); }
467 /// DINameSpace - A wrapper for a C++ style name space.
468 class DINameSpace : public DIScope {
470 explicit DINameSpace(MDNode *N = 0) : DIScope(N) {
471 if (DbgNode && !isNameSpace())
475 DIScope getContext() const { return getFieldAs<DIScope>(1); }
476 StringRef getName() const { return getStringField(2); }
477 StringRef getDirectory() const { return getContext().getDirectory(); }
478 StringRef getFilename() const { return getContext().getFilename(); }
479 DICompileUnit getCompileUnit() const { return getFieldAs<DICompileUnit>(3);}
480 unsigned getLineNumber() const { return getUnsignedField(4); }
483 /// DILocation - This object holds location information. This object
484 /// is not associated with any DWARF tag.
485 class DILocation : public DIDescriptor {
487 explicit DILocation(MDNode *N) : DIDescriptor(N) { }
489 unsigned getLineNumber() const { return getUnsignedField(0); }
490 unsigned getColumnNumber() const { return getUnsignedField(1); }
491 DIScope getScope() const { return getFieldAs<DIScope>(2); }
492 DILocation getOrigLocation() const { return getFieldAs<DILocation>(3); }
493 StringRef getFilename() const { return getScope().getFilename(); }
494 StringRef getDirectory() const { return getScope().getDirectory(); }
497 /// DIFactory - This object assists with the construction of the various
501 LLVMContext& VMContext;
503 Function *DeclareFn; // llvm.dbg.declare
504 Function *ValueFn; // llvm.dbg.value
506 DIFactory(const DIFactory &); // DO NOT IMPLEMENT
507 void operator=(const DIFactory&); // DO NOT IMPLEMENT
509 enum ComplexAddrKind { OpPlus=1, OpDeref };
511 explicit DIFactory(Module &m);
513 /// GetOrCreateArray - Create an descriptor for an array of descriptors.
514 /// This implicitly uniques the arrays created.
515 DIArray GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys);
517 /// GetOrCreateSubrange - Create a descriptor for a value range. This
518 /// implicitly uniques the values returned.
519 DISubrange GetOrCreateSubrange(int64_t Lo, int64_t Hi);
521 /// CreateCompileUnit - Create a new descriptor for the specified compile
523 DICompileUnit CreateCompileUnit(unsigned LangID,
528 bool isOptimized = false,
529 StringRef Flags = "",
530 unsigned RunTimeVer = 0);
532 /// CreateEnumerator - Create a single enumerator value.
533 DIEnumerator CreateEnumerator(StringRef Name, uint64_t Val);
535 /// CreateBasicType - Create a basic type like int, float, etc.
536 DIBasicType CreateBasicType(DIDescriptor Context, StringRef Name,
537 DICompileUnit CompileUnit, unsigned LineNumber,
538 uint64_t SizeInBits, uint64_t AlignInBits,
539 uint64_t OffsetInBits, unsigned Flags,
542 /// CreateBasicType - Create a basic type like int, float, etc.
543 DIBasicType CreateBasicTypeEx(DIDescriptor Context, StringRef Name,
544 DICompileUnit CompileUnit, unsigned LineNumber,
545 Constant *SizeInBits, Constant *AlignInBits,
546 Constant *OffsetInBits, unsigned Flags,
549 /// CreateDerivedType - Create a derived type like const qualified type,
550 /// pointer, typedef, etc.
551 DIDerivedType CreateDerivedType(unsigned Tag, DIDescriptor Context,
553 DICompileUnit CompileUnit,
555 uint64_t SizeInBits, uint64_t AlignInBits,
556 uint64_t OffsetInBits, unsigned Flags,
559 /// CreateDerivedType - Create a derived type like const qualified type,
560 /// pointer, typedef, etc.
561 DIDerivedType CreateDerivedTypeEx(unsigned Tag, DIDescriptor Context,
563 DICompileUnit CompileUnit,
565 Constant *SizeInBits, Constant *AlignInBits,
566 Constant *OffsetInBits, unsigned Flags,
569 /// CreateCompositeType - Create a composite type like array, struct, etc.
570 DICompositeType CreateCompositeType(unsigned Tag, DIDescriptor Context,
572 DICompileUnit CompileUnit,
575 uint64_t AlignInBits,
576 uint64_t OffsetInBits, unsigned Flags,
579 unsigned RunTimeLang = 0,
580 MDNode *ContainingType = 0);
582 /// CreateArtificialType - Create a new DIType with "artificial" flag set.
583 DIType CreateArtificialType(DIType Ty);
585 /// CreateCompositeType - Create a composite type like array, struct, etc.
586 DICompositeType CreateCompositeTypeEx(unsigned Tag, DIDescriptor Context,
588 DICompileUnit CompileUnit,
590 Constant *SizeInBits,
591 Constant *AlignInBits,
592 Constant *OffsetInBits, unsigned Flags,
595 unsigned RunTimeLang = 0);
597 /// CreateSubprogram - Create a new descriptor for the specified subprogram.
598 /// See comments in DISubprogram for descriptions of these fields.
599 DISubprogram CreateSubprogram(DIDescriptor Context, StringRef Name,
600 StringRef DisplayName,
601 StringRef LinkageName,
602 DICompileUnit CompileUnit, unsigned LineNo,
603 DIType Ty, bool isLocalToUnit,
608 bool isArtificial = 0);
610 /// CreateSubprogramDefinition - Create new subprogram descriptor for the
611 /// given declaration.
612 DISubprogram CreateSubprogramDefinition(DISubprogram &SPDeclaration);
614 /// CreateGlobalVariable - Create a new descriptor for the specified global.
616 CreateGlobalVariable(DIDescriptor Context, StringRef Name,
617 StringRef DisplayName,
618 StringRef LinkageName,
619 DICompileUnit CompileUnit,
620 unsigned LineNo, DIType Ty, bool isLocalToUnit,
621 bool isDefinition, llvm::GlobalVariable *GV);
623 /// CreateVariable - Create a new descriptor for the specified variable.
624 DIVariable CreateVariable(unsigned Tag, DIDescriptor Context,
626 DICompileUnit CompileUnit, unsigned LineNo,
629 /// CreateComplexVariable - Create a new descriptor for the specified
630 /// variable which has a complex address expression for its address.
631 DIVariable CreateComplexVariable(unsigned Tag, DIDescriptor Context,
632 const std::string &Name,
633 DICompileUnit CompileUnit, unsigned LineNo,
635 SmallVector<Value *, 9> &addr);
637 /// CreateLexicalBlock - This creates a descriptor for a lexical block
638 /// with the specified parent context.
639 DILexicalBlock CreateLexicalBlock(DIDescriptor Context);
641 /// CreateNameSpace - This creates new descriptor for a namespace
642 /// with the specified parent context.
643 DINameSpace CreateNameSpace(DIDescriptor Context, StringRef Name,
644 DICompileUnit CU, unsigned LineNo);
646 /// CreateLocation - Creates a debug info location.
647 DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
648 DIScope S, DILocation OrigLoc);
650 /// CreateLocation - Creates a debug info location.
651 DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
652 DIScope S, MDNode *OrigLoc = 0);
654 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
655 Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
656 BasicBlock *InsertAtEnd);
658 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
659 Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
660 Instruction *InsertBefore);
662 /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
663 Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
664 DIVariable D, BasicBlock *InsertAtEnd);
666 /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
667 Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
668 DIVariable D, Instruction *InsertBefore);
670 Constant *GetTagConstant(unsigned TAG);
673 bool getLocationInfo(const Value *V, std::string &DisplayName,
674 std::string &Type, unsigned &LineNo, std::string &File,
677 /// ExtractDebugLocation - Extract debug location information
679 DebugLoc ExtractDebugLocation(DILocation &Loc,
680 DebugLocTracker &DebugLocInfo);
682 /// getDISubprogram - Find subprogram that is enclosing this scope.
683 DISubprogram getDISubprogram(MDNode *Scope);
685 /// getDICompositeType - Find underlying composite type.
686 DICompositeType getDICompositeType(DIType T);
688 class DebugInfoFinder {
690 /// processModule - Process entire module and collect debug info
692 void processModule(Module &M);
695 /// processType - Process DIType.
696 void processType(DIType DT);
698 /// processLexicalBlock - Process DILexicalBlock.
699 void processLexicalBlock(DILexicalBlock LB);
701 /// processSubprogram - Process DISubprogram.
702 void processSubprogram(DISubprogram SP);
704 /// processDeclare - Process DbgDeclareInst.
705 void processDeclare(DbgDeclareInst *DDI);
707 /// processLocation - Process DILocation.
708 void processLocation(DILocation Loc);
710 /// addCompileUnit - Add compile unit into CUs.
711 bool addCompileUnit(DICompileUnit CU);
713 /// addGlobalVariable - Add global variable into GVs.
714 bool addGlobalVariable(DIGlobalVariable DIG);
716 // addSubprogram - Add subprgoram into SPs.
717 bool addSubprogram(DISubprogram SP);
719 /// addType - Add type into Tys.
720 bool addType(DIType DT);
723 typedef SmallVector<MDNode *, 8>::iterator iterator;
724 iterator compile_unit_begin() { return CUs.begin(); }
725 iterator compile_unit_end() { return CUs.end(); }
726 iterator subprogram_begin() { return SPs.begin(); }
727 iterator subprogram_end() { return SPs.end(); }
728 iterator global_variable_begin() { return GVs.begin(); }
729 iterator global_variable_end() { return GVs.end(); }
730 iterator type_begin() { return TYs.begin(); }
731 iterator type_end() { return TYs.end(); }
733 unsigned compile_unit_count() { return CUs.size(); }
734 unsigned global_variable_count() { return GVs.size(); }
735 unsigned subprogram_count() { return SPs.size(); }
736 unsigned type_count() { return TYs.size(); }
739 SmallVector<MDNode *, 8> CUs; // Compile Units
740 SmallVector<MDNode *, 8> SPs; // Subprograms
741 SmallVector<MDNode *, 8> GVs; // Global Variables;
742 SmallVector<MDNode *, 8> TYs; // Types
743 SmallPtrSet<MDNode *, 64> NodesSeen;
745 } // end namespace llvm