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/Metadata.h"
21 #include "llvm/Target/TargetMachine.h"
22 #include "llvm/ADT/StringMap.h"
23 #include "llvm/ADT/DenseMap.h"
24 #include "llvm/ADT/SmallVector.h"
25 #include "llvm/ADT/SmallPtrSet.h"
26 #include "llvm/Support/Dwarf.h"
27 #include "llvm/Support/ValueHandle.h"
29 #define ATTACH_DEBUG_INFO_TO_AN_INSN 1
39 struct DbgStopPointInst;
40 struct DbgDeclareInst;
41 struct DbgFuncStartInst;
42 struct DbgRegionStartInst;
43 struct DbgRegionEndInst;
45 struct DebugLocTracker;
51 TrackingVH<MDNode> DbgNode;
53 /// DIDescriptor constructor. If the specified node is non-null, check
54 /// to make sure that the tag in the descriptor matches 'RequiredTag'. If
55 /// not, the debug info is corrupt and we ignore it.
56 DIDescriptor(MDNode *N, unsigned RequiredTag);
58 const char *getStringField(unsigned Elt) const;
59 unsigned getUnsignedField(unsigned Elt) const {
60 return (unsigned)getUInt64Field(Elt);
62 uint64_t getUInt64Field(unsigned Elt) const;
63 DIDescriptor getDescriptorField(unsigned Elt) const;
65 template <typename DescTy>
66 DescTy getFieldAs(unsigned Elt) const {
67 return DescTy(getDescriptorField(Elt).getNode());
70 GlobalVariable *getGlobalVariableField(unsigned Elt) const;
73 explicit DIDescriptor() : DbgNode(0) {}
74 explicit DIDescriptor(MDNode *N) : DbgNode(N) {}
76 bool isNull() const { return DbgNode == 0; }
78 MDNode *getNode() const { return DbgNode; }
80 unsigned getVersion() const {
81 return getUnsignedField(0) & LLVMDebugVersionMask;
84 unsigned getTag() const {
85 return getUnsignedField(0) & ~LLVMDebugVersionMask;
88 /// ValidDebugInfo - Return true if N represents valid debug info value.
89 static bool ValidDebugInfo(MDNode *N, CodeGenOpt::Level OptLevel);
91 /// dump - print descriptor.
94 bool isDerivedType() const;
95 bool isCompositeType() const;
96 bool isBasicType() const;
97 bool isVariable() const;
98 bool isSubprogram() const;
99 bool isGlobalVariable() const;
100 bool isScope() const;
101 bool isCompileUnit() const;
102 bool isLexicalBlock() const;
103 bool isSubrange() const;
104 bool isEnumerator() const;
106 bool isGlobal() const;
109 /// DISubrange - This is used to represent ranges, for array bounds.
110 class DISubrange : public DIDescriptor {
112 explicit DISubrange(MDNode *N = 0)
113 : DIDescriptor(N, dwarf::DW_TAG_subrange_type) {}
115 int64_t getLo() const { return (int64_t)getUInt64Field(1); }
116 int64_t getHi() const { return (int64_t)getUInt64Field(2); }
119 /// DIArray - This descriptor holds an array of descriptors.
120 class DIArray : public DIDescriptor {
122 explicit DIArray(MDNode *N = 0)
125 unsigned getNumElements() const;
126 DIDescriptor getElement(unsigned Idx) const {
127 return getDescriptorField(Idx);
131 /// DIScope - A base class for various scopes.
132 class DIScope : public DIDescriptor {
134 explicit DIScope(MDNode *N = 0) : DIDescriptor (N) {
135 if (DbgNode && !isScope())
138 virtual ~DIScope() {}
140 const char *getFilename() const;
141 const char *getDirectory() const;
144 /// DICompileUnit - A wrapper for a compile unit.
145 class DICompileUnit : public DIScope {
147 explicit DICompileUnit(MDNode *N = 0) : DIScope(N) {
148 if (DbgNode && !isCompileUnit())
152 unsigned getLanguage() const { return getUnsignedField(2); }
153 const char *getFilename() const { return getStringField(3); }
154 const char *getDirectory() const { return getStringField(4); }
155 const char *getProducer() const { return getStringField(5); }
157 /// isMain - Each input file is encoded as a separate compile unit in LLVM
158 /// debugging information output. However, many target specific tool chains
159 /// prefer to encode only one compile unit in an object file. In this
160 /// situation, the LLVM code generator will include debugging information
161 /// entities in the compile unit that is marked as main compile unit. The
162 /// code generator accepts maximum one main compile unit per module. If a
163 /// module does not contain any main compile unit then the code generator
164 /// will emit multiple compile units in the output object file.
166 bool isMain() const { return getUnsignedField(6); }
167 bool isOptimized() const { return getUnsignedField(7); }
168 const char *getFlags() const { return getStringField(8); }
169 unsigned getRunTimeVersion() const { return getUnsignedField(9); }
171 /// Verify - Verify that a compile unit is well formed.
174 /// dump - print compile unit.
178 /// DIEnumerator - A wrapper for an enumerator (e.g. X and Y in 'enum {X,Y}').
179 /// FIXME: it seems strange that this doesn't have either a reference to the
180 /// type/precision or a file/line pair for location info.
181 class DIEnumerator : public DIDescriptor {
183 explicit DIEnumerator(MDNode *N = 0)
184 : DIDescriptor(N, dwarf::DW_TAG_enumerator) {}
186 const char *getName() const { return getStringField(1); }
187 uint64_t getEnumValue() const { return getUInt64Field(2); }
190 /// DIType - This is a wrapper for a type.
191 /// FIXME: Types should be factored much better so that CV qualifiers and
192 /// others do not require a huge and empty descriptor full of zeros.
193 class DIType : public DIDescriptor {
196 FlagPrivate = 1 << 0,
197 FlagProtected = 1 << 1,
198 FlagFwdDecl = 1 << 2,
199 FlagAppleBlock = 1 << 3,
200 FlagBlockByrefStruct = 1 << 4
204 DIType(MDNode *N, unsigned Tag)
205 : DIDescriptor(N, Tag) {}
206 // This ctor is used when the Tag has already been validated by a derived
208 DIType(MDNode *N, bool, bool) : DIDescriptor(N) {}
212 /// Verify - Verify that a type descriptor is well formed.
215 explicit DIType(MDNode *N);
219 DIDescriptor getContext() const { return getDescriptorField(1); }
220 const char *getName() const { return getStringField(2); }
221 DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
222 unsigned getLineNumber() const { return getUnsignedField(4); }
223 uint64_t getSizeInBits() const { return getUInt64Field(5); }
224 uint64_t getAlignInBits() const { return getUInt64Field(6); }
225 // FIXME: Offset is only used for DW_TAG_member nodes. Making every type
226 // carry this is just plain insane.
227 uint64_t getOffsetInBits() const { return getUInt64Field(7); }
228 unsigned getFlags() const { return getUnsignedField(8); }
229 bool isPrivate() const {
230 return (getFlags() & FlagPrivate) != 0;
232 bool isProtected() const {
233 return (getFlags() & FlagProtected) != 0;
235 bool isForwardDecl() const {
236 return (getFlags() & FlagFwdDecl) != 0;
238 // isAppleBlock - Return true if this is the Apple Blocks extension.
239 bool isAppleBlockExtension() const {
240 return (getFlags() & FlagAppleBlock) != 0;
242 bool isBlockByrefStruct() const {
243 return (getFlags() & FlagBlockByrefStruct) != 0;
246 /// dump - print type.
250 /// DIBasicType - A basic type, like 'int' or 'float'.
251 class DIBasicType : public DIType {
253 explicit DIBasicType(MDNode *N = 0)
254 : DIType(N, dwarf::DW_TAG_base_type) {}
256 unsigned getEncoding() const { return getUnsignedField(9); }
258 /// dump - print basic type.
262 /// DIDerivedType - A simple derived type, like a const qualified type,
263 /// a typedef, a pointer or reference, etc.
264 class DIDerivedType : public DIType {
266 explicit DIDerivedType(MDNode *N, bool, bool)
267 : DIType(N, true, true) {}
269 explicit DIDerivedType(MDNode *N = 0)
270 : DIType(N, true, true) {
271 if (DbgNode && !isDerivedType())
275 DIType getTypeDerivedFrom() const { return getFieldAs<DIType>(9); }
277 /// getOriginalTypeSize - If this type is derived from a base type then
278 /// return base type size.
279 uint64_t getOriginalTypeSize() const;
280 /// dump - print derived type.
283 /// replaceAllUsesWith - Replace all uses of debug info referenced by
284 /// this descriptor. After this completes, the current debug info value
286 void replaceAllUsesWith(DIDescriptor &D);
289 /// DICompositeType - This descriptor holds a type that can refer to multiple
290 /// other types, like a function or struct.
291 /// FIXME: Why is this a DIDerivedType??
292 class DICompositeType : public DIDerivedType {
294 explicit DICompositeType(MDNode *N = 0)
295 : DIDerivedType(N, true, true) {
296 if (N && !isCompositeType())
300 DIArray getTypeArray() const { return getFieldAs<DIArray>(10); }
301 unsigned getRunTimeLang() const { return getUnsignedField(11); }
303 /// Verify - Verify that a composite type descriptor is well formed.
306 /// dump - print composite type.
310 /// DIGlobal - This is a common class for global variables and subprograms.
311 class DIGlobal : public DIDescriptor {
313 explicit DIGlobal(MDNode *N, unsigned RequiredTag)
314 : DIDescriptor(N, RequiredTag) {}
317 virtual ~DIGlobal() {}
319 DIDescriptor getContext() const { return getDescriptorField(2); }
320 const char *getName() const { return getStringField(3); }
321 const char *getDisplayName() const { return getStringField(4); }
322 const char *getLinkageName() const { return getStringField(5); }
323 DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(6); }
324 unsigned getLineNumber() const { return getUnsignedField(7); }
325 DIType getType() const { return getFieldAs<DIType>(8); }
327 /// isLocalToUnit - Return true if this subprogram is local to the current
328 /// compile unit, like 'static' in C.
329 unsigned isLocalToUnit() const { return getUnsignedField(9); }
330 unsigned isDefinition() const { return getUnsignedField(10); }
332 /// dump - print global.
336 /// DISubprogram - This is a wrapper for a subprogram (e.g. a function).
337 class DISubprogram : public DIScope {
339 explicit DISubprogram(MDNode *N = 0) : DIScope(N) {
340 if (DbgNode && !isSubprogram())
344 DIDescriptor getContext() const { return getDescriptorField(2); }
345 const char *getName() const { return getStringField(3); }
346 const char *getDisplayName() const { return getStringField(4); }
347 const char *getLinkageName() const { return getStringField(5); }
348 DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(6); }
349 unsigned getLineNumber() const { return getUnsignedField(7); }
350 DICompositeType getType() const { return getFieldAs<DICompositeType>(8); }
352 /// getReturnTypeName - Subprogram return types are encoded either as
353 /// DIType or as DICompositeType.
354 const char *getReturnTypeName() const {
355 DICompositeType DCT(getFieldAs<DICompositeType>(8));
357 DIArray A = DCT.getTypeArray();
358 DIType T(A.getElement(0).getNode());
361 DIType T(getFieldAs<DIType>(8));
365 /// isLocalToUnit - Return true if this subprogram is local to the current
366 /// compile unit, like 'static' in C.
367 unsigned isLocalToUnit() const { return getUnsignedField(9); }
368 unsigned isDefinition() const { return getUnsignedField(10); }
369 const char *getFilename() const { return getCompileUnit().getFilename();}
370 const char *getDirectory() const { return getCompileUnit().getDirectory();}
372 /// Verify - Verify that a subprogram descriptor is well formed.
375 /// dump - print subprogram.
378 /// describes - Return true if this subprogram provides debugging
379 /// information for the function F.
380 bool describes(const Function *F);
383 /// DIGlobalVariable - This is a wrapper for a global variable.
384 class DIGlobalVariable : public DIGlobal {
386 explicit DIGlobalVariable(MDNode *N = 0)
387 : DIGlobal(N, dwarf::DW_TAG_variable) {}
389 GlobalVariable *getGlobal() const { return getGlobalVariableField(11); }
391 /// Verify - Verify that a global variable descriptor is well formed.
394 /// dump - print global variable.
398 /// DIVariable - This is a wrapper for a variable (e.g. parameter, local,
400 class DIVariable : public DIDescriptor {
402 explicit DIVariable(MDNode *N = 0)
404 if (DbgNode && !isVariable())
408 DIDescriptor getContext() const { return getDescriptorField(1); }
409 const char *getName() const { return getStringField(2); }
410 DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
411 unsigned getLineNumber() const { return getUnsignedField(4); }
412 DIType getType() const { return getFieldAs<DIType>(5); }
415 /// Verify - Verify that a variable descriptor is well formed.
418 /// HasComplexAddr - Return true if the variable has a complex address.
419 bool hasComplexAddress() const {
420 return getNumAddrElements() > 0;
423 unsigned getNumAddrElements() const { return DbgNode->getNumElements()-6; }
425 uint64_t getAddrElement(unsigned Idx) const {
426 return getUInt64Field(Idx+6);
429 /// isBlockByrefVariable - Return true if the variable was declared as
430 /// a "__block" variable (Apple Blocks).
431 bool isBlockByrefVariable() const {
432 return getType().isBlockByrefStruct();
435 /// dump - print variable.
439 /// DILexicalBlock - This is a wrapper for a lexical block.
440 class DILexicalBlock : public DIScope {
442 explicit DILexicalBlock(MDNode *N = 0) : DIScope(N) {
443 if (DbgNode && !isLexicalBlock())
446 DIScope getContext() const { return getFieldAs<DIScope>(1); }
447 const char *getDirectory() const { return getContext().getDirectory(); }
448 const char *getFilename() const { return getContext().getFilename(); }
451 /// DILocation - This object holds location information. This object
452 /// is not associated with any DWARF tag.
453 class DILocation : public DIDescriptor {
455 explicit DILocation(MDNode *N) : DIDescriptor(N) { ; }
457 unsigned getLineNumber() const { return getUnsignedField(0); }
458 unsigned getColumnNumber() const { return getUnsignedField(1); }
459 DIScope getScope() const { return getFieldAs<DIScope>(2); }
460 DILocation getOrigLocation() const { return getFieldAs<DILocation>(3); }
461 const char *getFilename() const { return getScope().getFilename(); }
462 const char *getDirectory() const { return getScope().getDirectory(); }
465 /// DIFactory - This object assists with the construction of the various
469 LLVMContext& VMContext;
471 // Cached values for uniquing and faster lookups.
472 const Type *EmptyStructPtr; // "{}*".
473 Function *StopPointFn; // llvm.dbg.stoppoint
474 Function *FuncStartFn; // llvm.dbg.func.start
475 Function *RegionStartFn; // llvm.dbg.region.start
476 Function *RegionEndFn; // llvm.dbg.region.end
477 Function *DeclareFn; // llvm.dbg.declare
478 StringMap<Constant*> StringCache;
479 DenseMap<Constant*, DIDescriptor> SimpleConstantCache;
481 DIFactory(const DIFactory &); // DO NOT IMPLEMENT
482 void operator=(const DIFactory&); // DO NOT IMPLEMENT
484 enum ComplexAddrKind { OpPlus=1, OpDeref };
486 explicit DIFactory(Module &m);
488 /// GetOrCreateArray - Create an descriptor for an array of descriptors.
489 /// This implicitly uniques the arrays created.
490 DIArray GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys);
492 /// GetOrCreateSubrange - Create a descriptor for a value range. This
493 /// implicitly uniques the values returned.
494 DISubrange GetOrCreateSubrange(int64_t Lo, int64_t Hi);
496 /// CreateCompileUnit - Create a new descriptor for the specified compile
498 DICompileUnit CreateCompileUnit(unsigned LangID,
503 bool isOptimized = false,
504 const char *Flags = "",
505 unsigned RunTimeVer = 0);
507 /// CreateEnumerator - Create a single enumerator value.
508 DIEnumerator CreateEnumerator(StringRef Name, uint64_t Val);
510 /// CreateBasicType - Create a basic type like int, float, etc.
511 DIBasicType CreateBasicType(DIDescriptor Context, StringRef Name,
512 DICompileUnit CompileUnit, unsigned LineNumber,
513 uint64_t SizeInBits, uint64_t AlignInBits,
514 uint64_t OffsetInBits, unsigned Flags,
517 /// CreateDerivedType - Create a derived type like const qualified type,
518 /// pointer, typedef, etc.
519 DIDerivedType CreateDerivedType(unsigned Tag, DIDescriptor Context,
521 DICompileUnit CompileUnit,
523 uint64_t SizeInBits, uint64_t AlignInBits,
524 uint64_t OffsetInBits, unsigned Flags,
527 /// CreateCompositeType - Create a composite type like array, struct, etc.
528 DICompositeType CreateCompositeType(unsigned Tag, DIDescriptor Context,
530 DICompileUnit CompileUnit,
533 uint64_t AlignInBits,
534 uint64_t OffsetInBits, unsigned Flags,
537 unsigned RunTimeLang = 0);
539 /// CreateSubprogram - Create a new descriptor for the specified subprogram.
540 /// See comments in DISubprogram for descriptions of these fields.
541 DISubprogram CreateSubprogram(DIDescriptor Context, StringRef Name,
542 StringRef DisplayName,
543 StringRef LinkageName,
544 DICompileUnit CompileUnit, unsigned LineNo,
545 DIType Type, bool isLocalToUnit,
548 /// CreateGlobalVariable - Create a new descriptor for the specified global.
550 CreateGlobalVariable(DIDescriptor Context, StringRef Name,
551 StringRef DisplayName,
552 StringRef LinkageName,
553 DICompileUnit CompileUnit,
554 unsigned LineNo, DIType Type, bool isLocalToUnit,
555 bool isDefinition, llvm::GlobalVariable *GV);
557 /// CreateVariable - Create a new descriptor for the specified variable.
558 DIVariable CreateVariable(unsigned Tag, DIDescriptor Context,
560 DICompileUnit CompileUnit, unsigned LineNo,
563 /// CreateComplexVariable - Create a new descriptor for the specified
564 /// variable which has a complex address expression for its address.
565 DIVariable CreateComplexVariable(unsigned Tag, DIDescriptor Context,
566 const std::string &Name,
567 DICompileUnit CompileUnit, unsigned LineNo,
569 SmallVector<Value *, 9> &addr);
571 /// CreateLexicalBlock - This creates a descriptor for a lexical block
572 /// with the specified parent context.
573 DILexicalBlock CreateLexicalBlock(DIDescriptor Context);
575 /// CreateLocation - Creates a debug info location.
576 DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
577 DIScope S, DILocation OrigLoc);
579 /// InsertStopPoint - Create a new llvm.dbg.stoppoint intrinsic invocation,
580 /// inserting it at the end of the specified basic block.
581 void InsertStopPoint(DICompileUnit CU, unsigned LineNo, unsigned ColNo,
584 /// InsertSubprogramStart - Create a new llvm.dbg.func.start intrinsic to
585 /// mark the start of the specified subprogram.
586 void InsertSubprogramStart(DISubprogram SP, BasicBlock *BB);
588 /// InsertRegionStart - Insert a new llvm.dbg.region.start intrinsic call to
589 /// mark the start of a region for the specified scoping descriptor.
590 void InsertRegionStart(DIDescriptor D, BasicBlock *BB);
592 /// InsertRegionEnd - Insert a new llvm.dbg.region.end intrinsic call to
593 /// mark the end of a region for the specified scoping descriptor.
594 void InsertRegionEnd(DIDescriptor D, BasicBlock *BB);
596 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
597 void InsertDeclare(llvm::Value *Storage, DIVariable D,
598 BasicBlock *InsertAtEnd);
600 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
601 void InsertDeclare(llvm::Value *Storage, DIVariable D,
602 Instruction *InsertBefore);
605 Constant *GetTagConstant(unsigned TAG);
608 /// Finds the stoppoint coressponding to this instruction, that is the
609 /// stoppoint that dominates this instruction
610 const DbgStopPointInst *findStopPoint(const Instruction *Inst);
612 /// Finds the stoppoint corresponding to first real (non-debug intrinsic)
613 /// instruction in this Basic Block, and returns the stoppoint for it.
614 const DbgStopPointInst *findBBStopPoint(const BasicBlock *BB);
616 /// Finds the dbg.declare intrinsic corresponding to this value if any.
617 /// It looks through pointer casts too.
618 const DbgDeclareInst *findDbgDeclare(const Value *V, bool stripCasts = true);
620 /// Find the debug info descriptor corresponding to this global variable.
621 Value *findDbgGlobalDeclare(GlobalVariable *V);
623 bool getLocationInfo(const Value *V, std::string &DisplayName,
624 std::string &Type, unsigned &LineNo, std::string &File,
627 /// isValidDebugInfoIntrinsic - Return true if SPI is a valid debug
629 bool isValidDebugInfoIntrinsic(DbgStopPointInst &SPI,
630 CodeGenOpt::Level OptLev);
632 /// isValidDebugInfoIntrinsic - Return true if FSI is a valid debug
634 bool isValidDebugInfoIntrinsic(DbgFuncStartInst &FSI,
635 CodeGenOpt::Level OptLev);
637 /// isValidDebugInfoIntrinsic - Return true if RSI is a valid debug
639 bool isValidDebugInfoIntrinsic(DbgRegionStartInst &RSI,
640 CodeGenOpt::Level OptLev);
642 /// isValidDebugInfoIntrinsic - Return true if REI is a valid debug
644 bool isValidDebugInfoIntrinsic(DbgRegionEndInst &REI,
645 CodeGenOpt::Level OptLev);
647 /// isValidDebugInfoIntrinsic - Return true if DI is a valid debug
649 bool isValidDebugInfoIntrinsic(DbgDeclareInst &DI,
650 CodeGenOpt::Level OptLev);
652 /// ExtractDebugLocation - Extract debug location information
653 /// from llvm.dbg.stoppoint intrinsic.
654 DebugLoc ExtractDebugLocation(DbgStopPointInst &SPI,
655 DebugLocTracker &DebugLocInfo);
657 /// ExtractDebugLocation - Extract debug location information
659 DebugLoc ExtractDebugLocation(DILocation &Loc,
660 DebugLocTracker &DebugLocInfo);
662 /// ExtractDebugLocation - Extract debug location information
663 /// from llvm.dbg.func_start intrinsic.
664 DebugLoc ExtractDebugLocation(DbgFuncStartInst &FSI,
665 DebugLocTracker &DebugLocInfo);
667 /// isInlinedFnStart - Return true if FSI is starting an inlined function.
668 bool isInlinedFnStart(DbgFuncStartInst &FSI, const Function *CurrentFn);
670 /// isInlinedFnEnd - Return true if REI is ending an inlined function.
671 bool isInlinedFnEnd(DbgRegionEndInst &REI, const Function *CurrentFn);
672 /// DebugInfoFinder - This object collects DebugInfo from a module.
673 class DebugInfoFinder {
676 /// processModule - Process entire module and collect debug info
678 void processModule(Module &M);
681 /// processType - Process DIType.
682 void processType(DIType DT);
684 /// processLexicalBlock - Process DILexicalBlock.
685 void processLexicalBlock(DILexicalBlock LB);
687 /// processSubprogram - Process DISubprogram.
688 void processSubprogram(DISubprogram SP);
690 /// processStopPoint - Process DbgStopPointInst.
691 void processStopPoint(DbgStopPointInst *SPI);
693 /// processFuncStart - Process DbgFuncStartInst.
694 void processFuncStart(DbgFuncStartInst *FSI);
696 /// processRegionStart - Process DbgRegionStart.
697 void processRegionStart(DbgRegionStartInst *DRS);
699 /// processRegionEnd - Process DbgRegionEnd.
700 void processRegionEnd(DbgRegionEndInst *DRE);
702 /// processDeclare - Process DbgDeclareInst.
703 void processDeclare(DbgDeclareInst *DDI);
705 /// addCompileUnit - Add compile unit into CUs.
706 bool addCompileUnit(DICompileUnit CU);
708 /// addGlobalVariable - Add global variable into GVs.
709 bool addGlobalVariable(DIGlobalVariable DIG);
711 // addSubprogram - Add subprgoram into SPs.
712 bool addSubprogram(DISubprogram SP);
714 /// addType - Add type into Tys.
715 bool addType(DIType DT);
718 typedef SmallVector<MDNode *, 8>::iterator iterator;
719 iterator compile_unit_begin() { return CUs.begin(); }
720 iterator compile_unit_end() { return CUs.end(); }
721 iterator subprogram_begin() { return SPs.begin(); }
722 iterator subprogram_end() { return SPs.end(); }
723 iterator global_variable_begin() { return GVs.begin(); }
724 iterator global_variable_end() { return GVs.end(); }
725 iterator type_begin() { return TYs.begin(); }
726 iterator type_end() { return TYs.end(); }
728 unsigned compile_unit_count() { return CUs.size(); }
729 unsigned global_variable_count() { return GVs.size(); }
730 unsigned subprogram_count() { return SPs.size(); }
731 unsigned type_count() { return TYs.size(); }
734 SmallVector<MDNode *, 8> CUs; // Compile Units
735 SmallVector<MDNode *, 8> SPs; // Subprograms
736 SmallVector<MDNode *, 8> GVs; // Global Variables;
737 SmallVector<MDNode *, 8> TYs; // Types
738 SmallPtrSet<MDNode *, 64> NodesSeen;
740 } // end namespace llvm