Make CreateComplexVariable independent of SmallVector.
[oota-llvm.git] / include / llvm / Analysis / DebugInfo.h
1 //===--- llvm/Analysis/DebugInfo.h - Debug Information Helpers --*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
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
13 // DWARF information.
14 //
15 //===----------------------------------------------------------------------===//
16
17 #ifndef LLVM_ANALYSIS_DEBUGINFO_H
18 #define LLVM_ANALYSIS_DEBUGINFO_H
19
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/SmallPtrSet.h"
22 #include "llvm/ADT/StringRef.h"
23 #include "llvm/Support/Dwarf.h"
24
25 namespace llvm {
26   class BasicBlock;
27   class Constant;
28   class Function;
29   class GlobalVariable;
30   class Module;
31   class Type;
32   class Value;
33   class DbgDeclareInst;
34   class Instruction;
35   class MDNode;
36   class LLVMContext;
37   class raw_ostream;
38
39   class DIFile;
40   class DISubprogram;
41   class DILexicalBlock;
42   class DIVariable;
43   class DIType;
44
45   /// DIDescriptor - A thin wraper around MDNode to access encoded debug info.
46   /// This should not be stored in a container, because underly MDNode may
47   /// change in certain situations.
48   class DIDescriptor {
49   protected:
50     const MDNode *DbgNode;
51
52     StringRef getStringField(unsigned Elt) const;
53     unsigned getUnsignedField(unsigned Elt) const {
54       return (unsigned)getUInt64Field(Elt);
55     }
56     uint64_t getUInt64Field(unsigned Elt) const;
57     DIDescriptor getDescriptorField(unsigned Elt) const;
58
59     template <typename DescTy>
60     DescTy getFieldAs(unsigned Elt) const {
61       return DescTy(getDescriptorField(Elt));
62     }
63
64     GlobalVariable *getGlobalVariableField(unsigned Elt) const;
65     Constant *getConstantField(unsigned Elt) const;
66     Function *getFunctionField(unsigned Elt) const;
67
68   public:
69     explicit DIDescriptor() : DbgNode(0) {}
70     explicit DIDescriptor(const MDNode *N) : DbgNode(N) {}
71     explicit DIDescriptor(const DIFile F);
72     explicit DIDescriptor(const DISubprogram F);
73     explicit DIDescriptor(const DILexicalBlock F);
74     explicit DIDescriptor(const DIVariable F);
75     explicit DIDescriptor(const DIType F);
76
77     bool Verify() const { return DbgNode != 0; }
78
79     operator MDNode *() const { return const_cast<MDNode*>(DbgNode); }
80     MDNode *operator ->() const { return const_cast<MDNode*>(DbgNode); }
81
82     unsigned getVersion() const {
83       return getUnsignedField(0) & LLVMDebugVersionMask;
84     }
85
86     unsigned getTag() const {
87       return getUnsignedField(0) & ~LLVMDebugVersionMask;
88     }
89
90     /// print - print descriptor.
91     void print(raw_ostream &OS) const;
92
93     /// dump - print descriptor to dbgs() with a newline.
94     void dump() const;
95
96     bool isDerivedType() const;
97     bool isCompositeType() const;
98     bool isBasicType() const;
99     bool isVariable() const;
100     bool isSubprogram() const;
101     bool isGlobalVariable() const;
102     bool isScope() const;
103     bool isFile() const;
104     bool isCompileUnit() const;
105     bool isNameSpace() const;
106     bool isLexicalBlock() const;
107     bool isSubrange() const;
108     bool isEnumerator() const;
109     bool isType() const;
110     bool isGlobal() const;
111   };
112
113   /// DISubrange - This is used to represent ranges, for array bounds.
114   class DISubrange : public DIDescriptor {
115   public:
116     explicit DISubrange(const MDNode *N = 0) : DIDescriptor(N) {}
117
118     int64_t getLo() const { return (int64_t)getUInt64Field(1); }
119     int64_t getHi() const { return (int64_t)getUInt64Field(2); }
120   };
121
122   /// DIArray - This descriptor holds an array of descriptors.
123   class DIArray : public DIDescriptor {
124   public:
125     explicit DIArray(const MDNode *N = 0)
126       : DIDescriptor(N) {}
127
128     unsigned getNumElements() const;
129     DIDescriptor getElement(unsigned Idx) const {
130       return getDescriptorField(Idx);
131     }
132   };
133
134   /// DIScope - A base class for various scopes.
135   class DIScope : public DIDescriptor {
136   public:
137     explicit DIScope(const MDNode *N = 0) : DIDescriptor (N) {}
138     virtual ~DIScope() {}
139
140     StringRef getFilename() const;
141     StringRef getDirectory() const;
142   };
143
144   /// DICompileUnit - A wrapper for a compile unit.
145   class DICompileUnit : public DIScope {
146   public:
147     explicit DICompileUnit(const MDNode *N = 0) : DIScope(N) {}
148
149     unsigned getLanguage() const   { return getUnsignedField(2); }
150     StringRef getFilename() const  { return getStringField(3);   }
151     StringRef getDirectory() const { return getStringField(4);   }
152     StringRef getProducer() const  { return getStringField(5);   }
153
154     /// isMain - Each input file is encoded as a separate compile unit in LLVM
155     /// debugging information output. However, many target specific tool chains
156     /// prefer to encode only one compile unit in an object file. In this
157     /// situation, the LLVM code generator will include  debugging information
158     /// entities in the compile unit that is marked as main compile unit. The
159     /// code generator accepts maximum one main compile unit per module. If a
160     /// module does not contain any main compile unit then the code generator
161     /// will emit multiple compile units in the output object file.
162
163     bool isMain() const                { return getUnsignedField(6); }
164     bool isOptimized() const           { return getUnsignedField(7); }
165     StringRef getFlags() const       { return getStringField(8);   }
166     unsigned getRunTimeVersion() const { return getUnsignedField(9); }
167
168     /// Verify - Verify that a compile unit is well formed.
169     bool Verify() const;
170
171     /// print - print compile unit.
172     void print(raw_ostream &OS) const;
173
174     /// dump - print compile unit to dbgs() with a newline.
175     void dump() const;
176   };
177
178   /// DIFile - This is a wrapper for a file.
179   class DIFile : public DIScope {
180   public:
181     explicit DIFile(const MDNode *N = 0) : DIScope(N) {
182       if (DbgNode && !isFile())
183         DbgNode = 0;
184     }
185     StringRef getFilename() const  { return getStringField(1);   }
186     StringRef getDirectory() const { return getStringField(2);   }
187     DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
188   };
189
190   /// DIEnumerator - A wrapper for an enumerator (e.g. X and Y in 'enum {X,Y}').
191   /// FIXME: it seems strange that this doesn't have either a reference to the
192   /// type/precision or a file/line pair for location info.
193   class DIEnumerator : public DIDescriptor {
194   public:
195     explicit DIEnumerator(const MDNode *N = 0) : DIDescriptor(N) {}
196
197     StringRef getName() const        { return getStringField(1); }
198     uint64_t getEnumValue() const      { return getUInt64Field(2); }
199   };
200
201   /// DIType - This is a wrapper for a type.
202   /// FIXME: Types should be factored much better so that CV qualifiers and
203   /// others do not require a huge and empty descriptor full of zeros.
204   class DIType : public DIScope {
205   public:
206     enum {
207       FlagPrivate          = 1 << 0,
208       FlagProtected        = 1 << 1,
209       FlagFwdDecl          = 1 << 2,
210       FlagAppleBlock       = 1 << 3,
211       FlagBlockByrefStruct = 1 << 4,
212       FlagVirtual          = 1 << 5,
213       FlagArtificial       = 1 << 6  // To identify artificial arguments in
214                                      // a subroutine type. e.g. "this" in c++.
215     };
216
217   protected:
218     // This ctor is used when the Tag has already been validated by a derived
219     // ctor.
220     DIType(const MDNode *N, bool, bool) : DIScope(N) {}
221
222   public:
223
224     /// Verify - Verify that a type descriptor is well formed.
225     bool Verify() const;
226   public:
227     explicit DIType(const MDNode *N);
228     explicit DIType() {}
229     virtual ~DIType() {}
230
231     DIScope getContext() const          { return getFieldAs<DIScope>(1); }
232     StringRef getName() const           { return getStringField(2);     }
233     DICompileUnit getCompileUnit() const{ 
234       if (getVersion() == llvm::LLVMDebugVersion7)
235         return getFieldAs<DICompileUnit>(3);
236
237       DIFile F = getFieldAs<DIFile>(3);
238       return F.getCompileUnit();
239     }
240     unsigned getLineNumber() const      { return getUnsignedField(4); }
241     uint64_t getSizeInBits() const      { return getUInt64Field(5); }
242     uint64_t getAlignInBits() const     { return getUInt64Field(6); }
243     // FIXME: Offset is only used for DW_TAG_member nodes.  Making every type
244     // carry this is just plain insane.
245     uint64_t getOffsetInBits() const    { return getUInt64Field(7); }
246     unsigned getFlags() const           { return getUnsignedField(8); }
247     bool isPrivate() const {
248       return (getFlags() & FlagPrivate) != 0;
249     }
250     bool isProtected() const {
251       return (getFlags() & FlagProtected) != 0;
252     }
253     bool isForwardDecl() const {
254       return (getFlags() & FlagFwdDecl) != 0;
255     }
256     // isAppleBlock - Return true if this is the Apple Blocks extension.
257     bool isAppleBlockExtension() const {
258       return (getFlags() & FlagAppleBlock) != 0;
259     }
260     bool isBlockByrefStruct() const {
261       return (getFlags() & FlagBlockByrefStruct) != 0;
262     }
263     bool isVirtual() const {
264       return (getFlags() & FlagVirtual) != 0;
265     }
266     bool isArtificial() const {
267       return (getFlags() & FlagArtificial) != 0;
268     }
269     bool isValid() const {
270       return DbgNode && (isBasicType() || isDerivedType() || isCompositeType());
271     }
272     StringRef getFilename() const    { return getCompileUnit().getFilename();}
273     StringRef getDirectory() const   { return getCompileUnit().getDirectory();}
274
275     /// replaceAllUsesWith - Replace all uses of debug info referenced by
276     /// this descriptor.
277     void replaceAllUsesWith(DIDescriptor &D);
278
279     /// print - print type.
280     void print(raw_ostream &OS) const;
281
282     /// dump - print type to dbgs() with a newline.
283     void dump() const;
284   };
285
286   /// DIBasicType - A basic type, like 'int' or 'float'.
287   class DIBasicType : public DIType {
288   public:
289     explicit DIBasicType(const MDNode *N = 0) : DIType(N) {}
290
291     unsigned getEncoding() const { return getUnsignedField(9); }
292
293     /// Verify - Verify that a basic type descriptor is well formed.
294     bool Verify() const;
295
296     /// print - print basic type.
297     void print(raw_ostream &OS) const;
298
299     /// dump - print basic type to dbgs() with a newline.
300     void dump() const;
301   };
302
303   /// DIDerivedType - A simple derived type, like a const qualified type,
304   /// a typedef, a pointer or reference, etc.
305   class DIDerivedType : public DIType {
306   protected:
307     explicit DIDerivedType(const MDNode *N, bool, bool)
308       : DIType(N, true, true) {}
309   public:
310     explicit DIDerivedType(const MDNode *N = 0)
311       : DIType(N, true, true) {}
312
313     DIType getTypeDerivedFrom() const { return getFieldAs<DIType>(9); }
314
315     /// getOriginalTypeSize - If this type is derived from a base type then
316     /// return base type size.
317     uint64_t getOriginalTypeSize() const;
318
319     /// Verify - Verify that a derived type descriptor is well formed.
320     bool Verify() const;
321
322     /// print - print derived type.
323     void print(raw_ostream &OS) const;
324
325     /// dump - print derived type to dbgs() with a newline.
326     void dump() const;
327   };
328
329   /// DICompositeType - This descriptor holds a type that can refer to multiple
330   /// other types, like a function or struct.
331   /// FIXME: Why is this a DIDerivedType??
332   class DICompositeType : public DIDerivedType {
333   public:
334     explicit DICompositeType(const MDNode *N = 0)
335       : DIDerivedType(N, true, true) {
336       if (N && !isCompositeType())
337         DbgNode = 0;
338     }
339
340     DIArray getTypeArray() const { return getFieldAs<DIArray>(10); }
341     unsigned getRunTimeLang() const { return getUnsignedField(11); }
342     DICompositeType getContainingType() const {
343       return getFieldAs<DICompositeType>(12);
344     }
345
346     /// Verify - Verify that a composite type descriptor is well formed.
347     bool Verify() const;
348
349     /// print - print composite type.
350     void print(raw_ostream &OS) const;
351
352     /// dump - print composite type to dbgs() with a newline.
353     void dump() const;
354   };
355
356   /// DISubprogram - This is a wrapper for a subprogram (e.g. a function).
357   class DISubprogram : public DIScope {
358   public:
359     explicit DISubprogram(const MDNode *N = 0) : DIScope(N) {}
360
361     DIScope getContext() const          { return getFieldAs<DIScope>(2); }
362     StringRef getName() const         { return getStringField(3); }
363     StringRef getDisplayName() const  { return getStringField(4); }
364     StringRef getLinkageName() const  { return getStringField(5); }
365     DICompileUnit getCompileUnit() const{ 
366       if (getVersion() == llvm::LLVMDebugVersion7)
367         return getFieldAs<DICompileUnit>(6);
368
369       DIFile F = getFieldAs<DIFile>(6); 
370       return F.getCompileUnit();
371     }
372     unsigned getLineNumber() const      { return getUnsignedField(7); }
373     DICompositeType getType() const { return getFieldAs<DICompositeType>(8); }
374
375     /// getReturnTypeName - Subprogram return types are encoded either as
376     /// DIType or as DICompositeType.
377     StringRef getReturnTypeName() const {
378       DICompositeType DCT(getFieldAs<DICompositeType>(8));
379       if (DCT.Verify()) {
380         DIArray A = DCT.getTypeArray();
381         DIType T(A.getElement(0));
382         return T.getName();
383       }
384       DIType T(getFieldAs<DIType>(8));
385       return T.getName();
386     }
387
388     /// isLocalToUnit - Return true if this subprogram is local to the current
389     /// compile unit, like 'static' in C.
390     unsigned isLocalToUnit() const     { return getUnsignedField(9); }
391     unsigned isDefinition() const      { return getUnsignedField(10); }
392
393     unsigned getVirtuality() const { return getUnsignedField(11); }
394     unsigned getVirtualIndex() const { return getUnsignedField(12); }
395
396     DICompositeType getContainingType() const {
397       return getFieldAs<DICompositeType>(13);
398     }
399     unsigned isArtificial() const    { return getUnsignedField(14); }
400     unsigned isOptimized() const;
401
402     StringRef getFilename() const    { 
403       if (getVersion() == llvm::LLVMDebugVersion7)
404         return getCompileUnit().getFilename();
405
406       DIFile F = getFieldAs<DIFile>(6); 
407       return F.getFilename();
408     }
409
410     StringRef getDirectory() const   { 
411       if (getVersion() == llvm::LLVMDebugVersion7)
412         return getCompileUnit().getFilename();
413
414       DIFile F = getFieldAs<DIFile>(6); 
415       return F.getDirectory();
416     }
417
418     /// Verify - Verify that a subprogram descriptor is well formed.
419     bool Verify() const;
420
421     /// print - print subprogram.
422     void print(raw_ostream &OS) const;
423
424     /// dump - print subprogram to dbgs() with a newline.
425     void dump() const;
426
427     /// describes - Return true if this subprogram provides debugging
428     /// information for the function F.
429     bool describes(const Function *F);
430
431     Function *getFunction() const { return getFunctionField(16); }
432   };
433
434   /// DIGlobalVariable - This is a wrapper for a global variable.
435   class DIGlobalVariable : public DIDescriptor {
436   public:
437     explicit DIGlobalVariable(const MDNode *N = 0) : DIDescriptor(N) {}
438
439     DIScope getContext() const          { return getFieldAs<DIScope>(2); }
440     StringRef getName() const         { return getStringField(3); }
441     StringRef getDisplayName() const  { return getStringField(4); }
442     StringRef getLinkageName() const  { return getStringField(5); }
443     DICompileUnit getCompileUnit() const{ 
444       if (getVersion() == llvm::LLVMDebugVersion7)
445         return getFieldAs<DICompileUnit>(6);
446
447       DIFile F = getFieldAs<DIFile>(6); 
448       return F.getCompileUnit();
449     }
450
451     unsigned getLineNumber() const      { return getUnsignedField(7); }
452     DIType getType() const              { return getFieldAs<DIType>(8); }
453     unsigned isLocalToUnit() const      { return getUnsignedField(9); }
454     unsigned isDefinition() const       { return getUnsignedField(10); }
455
456     GlobalVariable *getGlobal() const { return getGlobalVariableField(11); }
457     Constant *getConstant() const   { return getConstantField(11); }
458
459     /// Verify - Verify that a global variable descriptor is well formed.
460     bool Verify() const;
461
462     /// print - print global variable.
463     void print(raw_ostream &OS) const;
464
465     /// dump - print global variable to dbgs() with a newline.
466     void dump() const;
467   };
468
469   /// DIVariable - This is a wrapper for a variable (e.g. parameter, local,
470   /// global etc).
471   class DIVariable : public DIDescriptor {
472   public:
473     explicit DIVariable(const MDNode *N = 0)
474       : DIDescriptor(N) {}
475
476     DIScope getContext() const          { return getFieldAs<DIScope>(1); }
477     StringRef getName() const           { return getStringField(2);     }
478     DICompileUnit getCompileUnit() const{ 
479       if (getVersion() == llvm::LLVMDebugVersion7)
480         return getFieldAs<DICompileUnit>(3);
481
482       DIFile F = getFieldAs<DIFile>(3); 
483       return F.getCompileUnit();
484     }
485     unsigned getLineNumber() const      { return getUnsignedField(4); }
486     DIType getType() const              { return getFieldAs<DIType>(5); }
487
488
489     /// Verify - Verify that a variable descriptor is well formed.
490     bool Verify() const;
491
492     /// HasComplexAddr - Return true if the variable has a complex address.
493     bool hasComplexAddress() const {
494       return getNumAddrElements() > 0;
495     }
496
497     unsigned getNumAddrElements() const;
498     
499     uint64_t getAddrElement(unsigned Idx) const {
500       return getUInt64Field(Idx+6);
501     }
502
503     /// isBlockByrefVariable - Return true if the variable was declared as
504     /// a "__block" variable (Apple Blocks).
505     bool isBlockByrefVariable() const {
506       return getType().isBlockByrefStruct();
507     }
508
509     /// isInlinedFnArgument - Return trule if this variable provides debugging
510     /// information for an inlined function arguments.
511     bool isInlinedFnArgument(const Function *CurFn);
512
513     /// print - print variable.
514     void print(raw_ostream &OS) const;
515
516     /// dump - print variable to dbgs() with a newline.
517     void dump() const;
518   };
519
520   /// DILexicalBlock - This is a wrapper for a lexical block.
521   class DILexicalBlock : public DIScope {
522   public:
523     explicit DILexicalBlock(const MDNode *N = 0) : DIScope(N) {}
524     DIScope getContext() const       { return getFieldAs<DIScope>(1);      }
525     unsigned getLineNumber() const   { return getUnsignedField(2);         }
526     unsigned getColumnNumber() const { return getUnsignedField(3);         }
527     StringRef getDirectory() const {
528       DIFile F = getFieldAs<DIFile>(4);
529       StringRef dir = F.getDirectory();
530       return !dir.empty() ? dir : getContext().getDirectory();
531     }
532     StringRef getFilename() const {
533       DIFile F = getFieldAs<DIFile>(4);
534       StringRef filename = F.getFilename();
535       return !filename.empty() ? filename : getContext().getFilename();
536     }
537   };
538
539   /// DINameSpace - A wrapper for a C++ style name space.
540   class DINameSpace : public DIScope { 
541   public:
542     explicit DINameSpace(const MDNode *N = 0) : DIScope(N) {}
543     DIScope getContext() const     { return getFieldAs<DIScope>(1);      }
544     StringRef getName() const      { return getStringField(2);           }
545     StringRef getDirectory() const { return getContext().getDirectory(); }
546     StringRef getFilename() const  { return getContext().getFilename();  }
547     DICompileUnit getCompileUnit() const{ 
548       if (getVersion() == llvm::LLVMDebugVersion7)
549         return getFieldAs<DICompileUnit>(3);
550
551       DIFile F = getFieldAs<DIFile>(3); 
552       return F.getCompileUnit();
553     }
554     unsigned getLineNumber() const { return getUnsignedField(4);         }
555     bool Verify() const;
556   };
557
558   /// DILocation - This object holds location information. This object
559   /// is not associated with any DWARF tag.
560   class DILocation : public DIDescriptor {
561   public:
562     explicit DILocation(const MDNode *N) : DIDescriptor(N) { }
563
564     unsigned getLineNumber() const     { return getUnsignedField(0); }
565     unsigned getColumnNumber() const   { return getUnsignedField(1); }
566     DIScope  getScope() const          { return getFieldAs<DIScope>(2); }
567     DILocation getOrigLocation() const { return getFieldAs<DILocation>(3); }
568     StringRef getFilename() const    { return getScope().getFilename(); }
569     StringRef getDirectory() const   { return getScope().getDirectory(); }
570     bool Verify() const;
571   };
572
573   /// DIFactory - This object assists with the construction of the various
574   /// descriptors.
575   class DIFactory {
576     Module &M;
577     LLVMContext& VMContext;
578
579     Function *DeclareFn;     // llvm.dbg.declare
580     Function *ValueFn;       // llvm.dbg.value
581
582     DIFactory(const DIFactory &);     // DO NOT IMPLEMENT
583     void operator=(const DIFactory&); // DO NOT IMPLEMENT
584   public:
585     enum ComplexAddrKind { OpPlus=1, OpDeref };
586
587     explicit DIFactory(Module &m);
588
589     /// GetOrCreateArray - Create an descriptor for an array of descriptors.
590     /// This implicitly uniques the arrays created.
591     DIArray GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys);
592
593     /// GetOrCreateSubrange - Create a descriptor for a value range.  This
594     /// implicitly uniques the values returned.
595     DISubrange GetOrCreateSubrange(int64_t Lo, int64_t Hi);
596
597     /// CreateCompileUnit - Create a new descriptor for the specified compile
598     /// unit.
599     DICompileUnit CreateCompileUnit(unsigned LangID,
600                                     StringRef Filename,
601                                     StringRef Directory,
602                                     StringRef Producer,
603                                     bool isMain = false,
604                                     bool isOptimized = false,
605                                     StringRef Flags = "",
606                                     unsigned RunTimeVer = 0);
607
608     /// CreateFile -  Create a new descriptor for the specified file.
609     DIFile CreateFile(StringRef Filename, StringRef Directory,
610                       DICompileUnit CU);
611
612     /// CreateEnumerator - Create a single enumerator value.
613     DIEnumerator CreateEnumerator(StringRef Name, uint64_t Val);
614
615     /// CreateBasicType - Create a basic type like int, float, etc.
616     DIBasicType CreateBasicType(DIDescriptor Context, StringRef Name,
617                                 DIFile F, unsigned LineNumber,
618                                 uint64_t SizeInBits, uint64_t AlignInBits,
619                                 uint64_t OffsetInBits, unsigned Flags,
620                                 unsigned Encoding);
621
622     /// CreateBasicType - Create a basic type like int, float, etc.
623     DIBasicType CreateBasicTypeEx(DIDescriptor Context, StringRef Name,
624                                 DIFile F, unsigned LineNumber,
625                                 Constant *SizeInBits, Constant *AlignInBits,
626                                 Constant *OffsetInBits, unsigned Flags,
627                                 unsigned Encoding);
628
629     /// CreateDerivedType - Create a derived type like const qualified type,
630     /// pointer, typedef, etc.
631     DIDerivedType CreateDerivedType(unsigned Tag, DIDescriptor Context,
632                                     StringRef Name,
633                                     DIFile F,
634                                     unsigned LineNumber,
635                                     uint64_t SizeInBits, uint64_t AlignInBits,
636                                     uint64_t OffsetInBits, unsigned Flags,
637                                     DIType DerivedFrom);
638
639     /// CreateDerivedType - Create a derived type like const qualified type,
640     /// pointer, typedef, etc.
641     DIDerivedType CreateDerivedTypeEx(unsigned Tag, DIDescriptor Context,
642                                       StringRef Name,
643                                       DIFile F,
644                                       unsigned LineNumber,
645                                       Constant *SizeInBits, 
646                                       Constant *AlignInBits,
647                                       Constant *OffsetInBits, unsigned Flags,
648                                       DIType DerivedFrom);
649
650     /// CreateCompositeType - Create a composite type like array, struct, etc.
651     DICompositeType CreateCompositeType(unsigned Tag, DIDescriptor Context,
652                                         StringRef Name,
653                                         DIFile F,
654                                         unsigned LineNumber,
655                                         uint64_t SizeInBits,
656                                         uint64_t AlignInBits,
657                                         uint64_t OffsetInBits, unsigned Flags,
658                                         DIType DerivedFrom,
659                                         DIArray Elements,
660                                         unsigned RunTimeLang = 0,
661                                         MDNode *ContainingType = 0);
662
663     /// CreateTemporaryType - Create a temporary forward-declared type.
664     DIType CreateTemporaryType();
665
666     /// CreateArtificialType - Create a new DIType with "artificial" flag set.
667     DIType CreateArtificialType(DIType Ty);
668
669     /// CreateCompositeType - Create a composite type like array, struct, etc.
670     DICompositeType CreateCompositeTypeEx(unsigned Tag, DIDescriptor Context,
671                                           StringRef Name,
672                                           DIFile F,
673                                           unsigned LineNumber,
674                                           Constant *SizeInBits,
675                                           Constant *AlignInBits,
676                                           Constant *OffsetInBits, 
677                                           unsigned Flags,
678                                           DIType DerivedFrom,
679                                           DIArray Elements,
680                                           unsigned RunTimeLang = 0,
681                                           MDNode *ContainingType = 0);
682
683     /// CreateSubprogram - Create a new descriptor for the specified subprogram.
684     /// See comments in DISubprogram for descriptions of these fields.
685     DISubprogram CreateSubprogram(DIDescriptor Context, StringRef Name,
686                                   StringRef DisplayName,
687                                   StringRef LinkageName,
688                                   DIFile F, unsigned LineNo,
689                                   DIType Ty, bool isLocalToUnit,
690                                   bool isDefinition,
691                                   unsigned VK = 0,
692                                   unsigned VIndex = 0,
693                                   DIType = DIType(),
694                                   bool isArtificial = 0,
695                                   bool isOptimized = false,
696                                   Function *Fn = 0);
697
698     /// CreateSubprogramDefinition - Create new subprogram descriptor for the
699     /// given declaration. 
700     DISubprogram CreateSubprogramDefinition(DISubprogram &SPDeclaration);
701
702     /// CreateGlobalVariable - Create a new descriptor for the specified global.
703     DIGlobalVariable
704     CreateGlobalVariable(DIDescriptor Context, StringRef Name,
705                          StringRef DisplayName,
706                          StringRef LinkageName,
707                          DIFile F,
708                          unsigned LineNo, DIType Ty, bool isLocalToUnit,
709                          bool isDefinition, llvm::GlobalVariable *GV);
710
711     /// CreateGlobalVariable - Create a new descriptor for the specified constant.
712     DIGlobalVariable
713     CreateGlobalVariable(DIDescriptor Context, StringRef Name,
714                          StringRef DisplayName,
715                          StringRef LinkageName,
716                          DIFile F,
717                          unsigned LineNo, DIType Ty, bool isLocalToUnit,
718                          bool isDefinition, llvm::Constant *C);
719
720     /// CreateVariable - Create a new descriptor for the specified variable.
721     DIVariable CreateVariable(unsigned Tag, DIDescriptor Context,
722                               StringRef Name,
723                               DIFile F, unsigned LineNo,
724                               DIType Ty, bool AlwaysPreserve = false);
725
726     /// CreateComplexVariable - Create a new descriptor for the specified
727     /// variable which has a complex address expression for its address.
728     DIVariable CreateComplexVariable(unsigned Tag, DIDescriptor Context,
729                                      StringRef Name, DIFile F, unsigned LineNo,
730                                      DIType Ty, Value *const *Addr,
731                                      unsigned NumAddr);
732
733     /// CreateLexicalBlock - This creates a descriptor for a lexical block
734     /// with the specified parent context.
735     DILexicalBlock CreateLexicalBlock(DIDescriptor Context, DIFile F,
736                                       unsigned Line = 0, unsigned Col = 0);
737
738     /// CreateNameSpace - This creates new descriptor for a namespace
739     /// with the specified parent context.
740     DINameSpace CreateNameSpace(DIDescriptor Context, StringRef Name,
741                                 DIFile F, unsigned LineNo);
742
743     /// CreateLocation - Creates a debug info location.
744     DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
745                               DIScope S, DILocation OrigLoc);
746
747     /// CreateLocation - Creates a debug info location.
748     DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
749                               DIScope S, MDNode *OrigLoc = 0);
750
751     /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
752     Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
753                                BasicBlock *InsertAtEnd);
754
755     /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
756     Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
757                                Instruction *InsertBefore);
758
759     /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
760     Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
761                                          DIVariable D, BasicBlock *InsertAtEnd);
762
763     /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
764     Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,
765                                        DIVariable D, Instruction *InsertBefore);
766   private:
767     Constant *GetTagConstant(unsigned TAG);
768   };
769
770   bool getLocationInfo(const Value *V, std::string &DisplayName,
771                        std::string &Type, unsigned &LineNo, std::string &File,
772                        std::string &Dir);
773
774   /// getDISubprogram - Find subprogram that is enclosing this scope.
775   DISubprogram getDISubprogram(const MDNode *Scope);
776
777   /// getDICompositeType - Find underlying composite type.
778   DICompositeType getDICompositeType(DIType T);
779
780   class DebugInfoFinder {
781   public:
782     /// processModule - Process entire module and collect debug info
783     /// anchors.
784     void processModule(Module &M);
785
786   private:
787     /// processType - Process DIType.
788     void processType(DIType DT);
789
790     /// processLexicalBlock - Process DILexicalBlock.
791     void processLexicalBlock(DILexicalBlock LB);
792
793     /// processSubprogram - Process DISubprogram.
794     void processSubprogram(DISubprogram SP);
795
796     /// processDeclare - Process DbgDeclareInst.
797     void processDeclare(DbgDeclareInst *DDI);
798
799     /// processLocation - Process DILocation.
800     void processLocation(DILocation Loc);
801
802     /// addCompileUnit - Add compile unit into CUs.
803     bool addCompileUnit(DICompileUnit CU);
804
805     /// addGlobalVariable - Add global variable into GVs.
806     bool addGlobalVariable(DIGlobalVariable DIG);
807
808     // addSubprogram - Add subprgoram into SPs.
809     bool addSubprogram(DISubprogram SP);
810
811     /// addType - Add type into Tys.
812     bool addType(DIType DT);
813
814   public:
815     typedef SmallVector<MDNode *, 8>::const_iterator iterator;
816     iterator compile_unit_begin()    const { return CUs.begin(); }
817     iterator compile_unit_end()      const { return CUs.end(); }
818     iterator subprogram_begin()      const { return SPs.begin(); }
819     iterator subprogram_end()        const { return SPs.end(); }
820     iterator global_variable_begin() const { return GVs.begin(); }
821     iterator global_variable_end()   const { return GVs.end(); }
822     iterator type_begin()            const { return TYs.begin(); }
823     iterator type_end()              const { return TYs.end(); }
824
825     unsigned compile_unit_count()    const { return CUs.size(); }
826     unsigned global_variable_count() const { return GVs.size(); }
827     unsigned subprogram_count()      const { return SPs.size(); }
828     unsigned type_count()            const { return TYs.size(); }
829
830   private:
831     SmallVector<MDNode *, 8> CUs;  // Compile Units
832     SmallVector<MDNode *, 8> SPs;  // Subprograms
833     SmallVector<MDNode *, 8> GVs;  // Global Variables;
834     SmallVector<MDNode *, 8> TYs;  // Types
835     SmallPtrSet<MDNode *, 64> NodesSeen;
836   };
837 } // end namespace llvm
838
839 #endif