Match declaration to definition.
[oota-llvm.git] / include / llvm / Analysis / DebugInfo.h
index c80a11d3b32c21394e402b4325fa635e3f88a4d6..91046c2c8669e8d8b5c34684640d026c8cf9c625 100644 (file)
@@ -8,15 +8,19 @@
 //===----------------------------------------------------------------------===//
 //
 // This file defines a bunch of datatypes that are useful for creating and
-// walking debug info in LLVM IR form.
+// walking debug info in LLVM IR form. They essentially provide wrappers around
+// the information in the global variables that's needed when constructing the
+// DWARF information.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_SUPPORT_DEBUGINFO_H
-#define LLVM_SUPPORT_DEBUGINFO_H
+#ifndef LLVM_ANALYSIS_DEBUGINFO_H
+#define LLVM_ANALYSIS_DEBUGINFO_H
 
+#include "llvm/Target/TargetMachine.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Dwarf.h"
 
 namespace llvm {
@@ -27,20 +31,26 @@ namespace llvm {
   class Module;
   class Type;
   class Value;
-  class DbgStopPointInst;
-  class DbgDeclareInst;
+  struct DbgStopPointInst;
+  struct DbgDeclareInst;
+  struct DbgFuncStartInst;
+  struct DbgRegionStartInst;
+  struct DbgRegionEndInst;
+  class DebugLoc;
+  struct DebugLocTracker;
   class Instruction;
+  class LLVMContext;
 
   class DIDescriptor {
   protected:    
-    GlobalVariable *GV;
+    GlobalVariable *DbgGV;
 
     /// DIDescriptor constructor.  If the specified GV is non-null, this checks
     /// to make sure that the tag in the descriptor matches 'RequiredTag'.  If
     /// not, the debug info is corrupt and we ignore it.
     DIDescriptor(GlobalVariable *GV, unsigned RequiredTag);
 
-    std::string getStringField(unsigned Elt) const;
+    const std::string &getStringField(unsigned Elt, std::string &Result) const;
     unsigned getUnsignedField(unsigned Elt) const {
       return (unsigned)getUInt64Field(Elt);
     }
@@ -55,12 +65,12 @@ namespace llvm {
     GlobalVariable *getGlobalVariableField(unsigned Elt) const;
 
   public:
-    explicit DIDescriptor() : GV(0) {}
-    explicit DIDescriptor(GlobalVariable *gv) : GV(gv) {}
+    explicit DIDescriptor() : DbgGV(0) {}
+    explicit DIDescriptor(GlobalVariable *GV) : DbgGV(GV) {}
 
-    bool isNull() const { return GV == 0; }
+    bool isNull() const { return DbgGV == 0; }
 
-    GlobalVariable *getGV() const { return GV; }
+    GlobalVariable *getGV() const { return DbgGV; }
 
     unsigned getVersion() const {
       return getUnsignedField(0) & LLVMDebugVersionMask;
@@ -70,20 +80,18 @@ namespace llvm {
       return getUnsignedField(0) & ~LLVMDebugVersionMask;
     }
 
-  };
-
-  /// DIAnchor - A wrapper for various anchor descriptors.
-  class DIAnchor : public DIDescriptor {
-  public:
-    explicit DIAnchor(GlobalVariable *GV = 0);
+    /// ValidDebugInfo - Return true if V represents valid debug info value.
+    static bool ValidDebugInfo(Value *V, CodeGenOpt::Level OptLevel);
 
-    unsigned getAnchorTag() const { return getUnsignedField(1); }
+    /// dump - print descriptor.
+    void dump() const;
   };
 
   /// DISubrange - This is used to represent ranges, for array bounds.
   class DISubrange : public DIDescriptor {
   public:
-    explicit DISubrange(GlobalVariable *GV = 0);
+    explicit DISubrange(GlobalVariable *GV = 0)
+      : DIDescriptor(GV, dwarf::DW_TAG_subrange_type) {}
 
     int64_t getLo() const { return (int64_t)getUInt64Field(1); }
     int64_t getHi() const { return (int64_t)getUInt64Field(2); }
@@ -103,17 +111,41 @@ namespace llvm {
   /// DICompileUnit - A wrapper for a compile unit.
   class DICompileUnit : public DIDescriptor {
   public:
-    explicit DICompileUnit(GlobalVariable *GV = 0);
+    explicit DICompileUnit(GlobalVariable *GV = 0)
+      : DIDescriptor(GV, dwarf::DW_TAG_compile_unit) {}
 
     unsigned getLanguage() const     { return getUnsignedField(2); }
-    std::string getFilename() const  { return getStringField(3); }
-    std::string getDirectory() const { return getStringField(4); }
-    std::string getProducer() const  { return getStringField(5); }
-    bool isOptimized() const         { return getUnsignedField(6); }
-    std::string getFlags() const     { return getStringField(7); }
+    const std::string &getFilename(std::string &F) const {
+      return getStringField(3, F);
+    }
+    const std::string &getDirectory(std::string &F) const {
+      return getStringField(4, F);
+    }
+    const std::string &getProducer(std::string &F) const {
+      return getStringField(5, F);
+    }
+    
+    /// isMain - Each input file is encoded as a separate compile unit in LLVM
+    /// debugging information output. However, many target specific tool chains
+    /// prefer to encode only one compile unit in an object file. In this 
+    /// situation, the LLVM code generator will include  debugging information
+    /// entities in the compile unit that is marked as main compile unit. The 
+    /// code generator accepts maximum one main compile unit per module. If a
+    /// module does not contain any main compile unit then the code generator 
+    /// will emit multiple compile units in the output object file.
+
+    bool isMain() const                { return getUnsignedField(6); }
+    bool isOptimized() const           { return getUnsignedField(7); }
+    const std::string &getFlags(std::string &F) const {
+      return getStringField(8, F);
+    }
+    unsigned getRunTimeVersion() const { return getUnsignedField(9); }
 
     /// Verify - Verify that a compile unit is well formed.
     bool Verify() const;
+
+    /// dump - print compile unit.
+    void dump() const;
   };
 
   /// DIEnumerator - A wrapper for an enumerator (e.g. X and Y in 'enum {X,Y}').
@@ -121,9 +153,12 @@ namespace llvm {
   /// type/precision or a file/line pair for location info.
   class DIEnumerator : public DIDescriptor {
   public:
-    explicit DIEnumerator(GlobalVariable *GV = 0);
+    explicit DIEnumerator(GlobalVariable *GV = 0)
+      : DIDescriptor(GV, dwarf::DW_TAG_enumerator) {}
 
-    std::string getName() const  { return getStringField(1); }
+    const std::string &getName(std::string &F) const {
+      return getStringField(1, F);
+    }
     uint64_t getEnumValue() const { return getUInt64Field(2); }
   };
 
@@ -167,7 +202,9 @@ namespace llvm {
     virtual ~DIType() {}
 
     DIDescriptor getContext() const     { return getDescriptorField(1); }
-    std::string getName() const         { return getStringField(2); }
+    const std::string &getName(std::string &F) const {
+      return getStringField(2, F);
+    }
     DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
     unsigned getLineNumber() const      { return getUnsignedField(4); }
     uint64_t getSizeInBits() const      { return getUInt64Field(5); }
@@ -180,25 +217,20 @@ namespace llvm {
     bool isProtected() const            { return (getFlags() & FlagProtected) != 0; }
     bool isForwardDecl() const          { return (getFlags() & FlagFwdDecl) != 0; }
 
-    virtual std::string getFilename() const { 
-      assert (0 && "Invalid DIDescriptor");
-      return "";
-    }
-
-    virtual std::string getDirectory() const { 
-      assert (0 && "Invalid DIDescriptor");
-      return "";
-    }
+    /// dump - print type.
+    void dump() const;
   };
 
   /// DIBasicType - A basic type, like 'int' or 'float'.
   class DIBasicType : public DIType {
   public:
-    explicit DIBasicType(GlobalVariable *GV);
+    explicit DIBasicType(GlobalVariable *GV)
+      : DIType(GV, dwarf::DW_TAG_base_type) {}
 
     unsigned getEncoding() const { return getUnsignedField(9); }
-    std::string getFilename() const { return getStringField(10); }
-    std::string getDirectory() const { return getStringField(11); }
+
+    /// dump - print basic type.
+    void dump() const;
   };
 
   /// DIDerivedType - A simple derived type, like a const qualified type,
@@ -208,11 +240,19 @@ namespace llvm {
     explicit DIDerivedType(GlobalVariable *GV, bool, bool)
       : DIType(GV, true, true) {}
   public:
-    explicit DIDerivedType(GlobalVariable *GV);
+    explicit DIDerivedType(GlobalVariable *GV)
+      : DIType(GV, true, true) {
+      if (GV && !isDerivedType(getTag()))
+        DbgGV = 0;
+    }
 
     DIType getTypeDerivedFrom() const { return getFieldAs<DIType>(9); }
-    std::string getFilename() const { return getStringField(10); }
-    std::string getDirectory() const { return getStringField(11); }
+
+    /// getOriginalTypeSize - If this type is derived from a base type then
+    /// return base type size.
+    uint64_t getOriginalTypeSize() const;
+    /// dump - print derived type.
+    void dump() const;
   };
 
   /// DICompositeType - This descriptor holds a type that can refer to multiple
@@ -220,14 +260,20 @@ namespace llvm {
   /// FIXME: Why is this a DIDerivedType??
   class DICompositeType : public DIDerivedType {
   public:
-    explicit DICompositeType(GlobalVariable *GV);
+    explicit DICompositeType(GlobalVariable *GV)
+      : DIDerivedType(GV, true, true) {
+      if (GV && !isCompositeType(getTag()))
+        DbgGV = 0;
+    }
 
     DIArray getTypeArray() const { return getFieldAs<DIArray>(10); }
-    std::string getFilename() const { return getStringField(11); }
-    std::string getDirectory() const { return getStringField(12); }
+    unsigned getRunTimeLang() const { return getUnsignedField(11); }
 
     /// Verify - Verify that a composite type descriptor is well formed.
     bool Verify() const;
+
+    /// dump - print composite type.
+    void dump() const;
   };
 
   /// DIGlobal - This is a common class for global variables and subprograms.
@@ -252,9 +298,15 @@ namespace llvm {
     virtual ~DIGlobal() {}
 
     DIDescriptor getContext() const     { return getDescriptorField(2); }
-    std::string getName() const         { return getStringField(3); }
-    std::string getDisplayName() const  { return getStringField(4); }
-    std::string getLinkageName() const  { return getStringField(5); }
+    const std::string &getName(std::string &F) const {
+      return getStringField(3, F);
+    }
+    const std::string &getDisplayName(std::string &F) const {
+      return getStringField(4, F);
+    }
+    const std::string &getLinkageName(std::string &F) const {
+      return getStringField(5, F);
+    }
     DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(6); }
     unsigned getLineNumber() const      { return getUnsignedField(7); }
     DIType getType() const              { return getFieldAs<DIType>(8); }
@@ -264,68 +316,91 @@ namespace llvm {
     unsigned isLocalToUnit() const      { return getUnsignedField(9); }
     unsigned isDefinition() const       { return getUnsignedField(10); }
 
-    virtual std::string getFilename() const { 
-      assert (0 && "Invalid DIDescriptor");
-      return "";
-    }
-
-    virtual std::string getDirectory() const { 
-      assert (0 && "Invalid DIDescriptor");
-      return "";
-    }
+    /// dump - print global.
+    void dump() const;
   };
 
   /// DISubprogram - This is a wrapper for a subprogram (e.g. a function).
   class DISubprogram : public DIGlobal {
   public:
-    explicit DISubprogram(GlobalVariable *GV = 0);
-    std::string getFilename() const { return getStringField(11); }
-    std::string getDirectory() const { return getStringField(12); }
+    explicit DISubprogram(GlobalVariable *GV = 0)
+      : DIGlobal(GV, dwarf::DW_TAG_subprogram) {}
+
     DICompositeType getType() const { return getFieldAs<DICompositeType>(8); }
 
+    /// getReturnTypeName - Subprogram return types are encoded either as
+    /// DIType or as DICompositeType.
+    const std::string &getReturnTypeName(std::string &F) const {
+      DICompositeType DCT(getFieldAs<DICompositeType>(8));
+      if (!DCT.isNull()) {
+        DIArray A = DCT.getTypeArray();
+        DIType T(A.getElement(0).getGV());
+        return T.getName(F);
+      }
+      DIType T(getFieldAs<DIType>(8));
+      return T.getName(F);
+    }
+
     /// Verify - Verify that a subprogram descriptor is well formed.
     bool Verify() const;
+
+    /// dump - print subprogram.
+    void dump() const;
+
+    /// describes - Return true if this subprogram provides debugging
+    /// information for the function F.
+    bool describes(const Function *F);
   };
 
   /// DIGlobalVariable - This is a wrapper for a global variable.
   class DIGlobalVariable : public DIGlobal {
   public:
-    explicit DIGlobalVariable(GlobalVariable *GV = 0);
+    explicit DIGlobalVariable(GlobalVariable *GV = 0)
+      : DIGlobal(GV, dwarf::DW_TAG_variable) {}
 
     GlobalVariable *getGlobal() const { return getGlobalVariableField(11); }
-    std::string getFilename() const { return getStringField(12); }
-    std::string getDirectory() const { return getStringField(13); }
 
     /// Verify - Verify that a global variable descriptor is well formed.
     bool Verify() const;
+
+    /// dump - print global variable.
+    void dump() const;
   };
 
   /// DIVariable - This is a wrapper for a variable (e.g. parameter, local,
   /// global etc).
   class DIVariable : public DIDescriptor {
   public:
-    explicit DIVariable(GlobalVariable *GV = 0);
+    explicit DIVariable(GlobalVariable *GV = 0)
+      : DIDescriptor(GV) {
+      if (GV && !isVariable(getTag()))
+        DbgGV = 0;
+    }
 
     DIDescriptor getContext() const { return getDescriptorField(1); }
-    std::string getName() const { return getStringField(2); }
+    const std::string &getName(std::string &F) const {
+      return getStringField(2, F);
+    }
     DICompileUnit getCompileUnit() const{ return getFieldAs<DICompileUnit>(3); }
     unsigned getLineNumber() const      { return getUnsignedField(4); }
     DIType getType() const              { return getFieldAs<DIType>(5); }
-    std::string getFilename() const { return getStringField(6); }
-    std::string getDirectory() const { return getStringField(7); }
 
     /// isVariable - Return true if the specified tag is legal for DIVariable.
     static bool isVariable(unsigned Tag);
 
     /// Verify - Verify that a variable descriptor is well formed.
     bool Verify() const;
+
+    /// dump - print variable.
+    void dump() const;
   };
 
   /// DIBlock - This is a wrapper for a block (e.g. a function, scope, etc).
   class DIBlock : public DIDescriptor {
   public:
-    explicit DIBlock(GlobalVariable *GV = 0);
-    
+    explicit DIBlock(GlobalVariable *GV = 0)
+      : DIDescriptor(GV, dwarf::DW_TAG_lexical_block) {}
+
     DIDescriptor getContext() const { return getDescriptorField(1); }
   };
 
@@ -333,8 +408,9 @@ namespace llvm {
   /// descriptors.
   class DIFactory {
     Module &M;
+    LLVMContext& VMContext;
+    
     // Cached values for uniquing and faster lookups.
-    DIAnchor CompileUnitAnchor, SubProgramAnchor, GlobalVariableAnchor;
     const Type *EmptyStructPtr; // "{}*".
     Function *StopPointFn;   // llvm.dbg.stoppoint
     Function *FuncStartFn;   // llvm.dbg.func.start
@@ -349,18 +425,6 @@ namespace llvm {
   public:
     explicit DIFactory(Module &m);
 
-    /// GetOrCreateCompileUnitAnchor - Return the anchor for compile units,
-    /// creating a new one if there isn't already one in the module.
-    DIAnchor GetOrCreateCompileUnitAnchor();
-
-    /// GetOrCreateSubprogramAnchor - Return the anchor for subprograms,
-    /// creating a new one if there isn't already one in the module.
-    DIAnchor GetOrCreateSubprogramAnchor();
-
-    /// GetOrCreateGlobalVariableAnchor - Return the anchor for globals,
-    /// creating a new one if there isn't already one in the module.
-    DIAnchor GetOrCreateGlobalVariableAnchor();
-
     /// GetOrCreateArray - Create an descriptor for an array of descriptors. 
     /// This implicitly uniques the arrays created.
     DIArray GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys);
@@ -375,8 +439,10 @@ namespace llvm {
                                     const std::string &Filename,
                                     const std::string &Directory,
                                     const std::string &Producer,
+                                    bool isMain = false,
                                     bool isOptimized = false,
-                                    const char *Flags = "");
+                                    const char *Flags = "",
+                                    unsigned RunTimeVer = 0);
 
     /// CreateEnumerator - Create a single enumerator value.
     DIEnumerator CreateEnumerator(const std::string &Name, uint64_t Val);
@@ -386,9 +452,7 @@ namespace llvm {
                                 DICompileUnit CompileUnit, unsigned LineNumber,
                                 uint64_t SizeInBits, uint64_t AlignInBits,
                                 uint64_t OffsetInBits, unsigned Flags,
-                                unsigned Encoding,
-                                const std::string *FileName = 0,
-                                const std::string *Directory = 0);
+                                unsigned Encoding);
 
     /// CreateDerivedType - Create a derived type like const qualified type,
     /// pointer, typedef, etc.
@@ -398,9 +462,7 @@ namespace llvm {
                                     unsigned LineNumber,
                                     uint64_t SizeInBits, uint64_t AlignInBits,
                                     uint64_t OffsetInBits, unsigned Flags,
-                                    DIType DerivedFrom,
-                                    const std::string *FileName = 0,
-                                    const std::string *Directory = 0);
+                                    DIType DerivedFrom);
 
     /// CreateCompositeType - Create a composite type like array, struct, etc.
     DICompositeType CreateCompositeType(unsigned Tag, DIDescriptor Context,
@@ -412,8 +474,7 @@ namespace llvm {
                                         uint64_t OffsetInBits, unsigned Flags,
                                         DIType DerivedFrom,
                                         DIArray Elements,
-                                        const std::string *FileName = 0,
-                                        const std::string *Directory = 0);
+                                        unsigned RunTimeLang = 0);
 
     /// CreateSubprogram - Create a new descriptor for the specified subprogram.
     /// See comments in DISubprogram for descriptions of these fields.
@@ -422,9 +483,7 @@ namespace llvm {
                                   const std::string &LinkageName,
                                   DICompileUnit CompileUnit, unsigned LineNo,
                                   DIType Type, bool isLocalToUnit,
-                                  bool isDefinition,
-                                  const std::string *FileName = 0,
-                                  const std::string *Directory = 0);
+                                  bool isDefinition);
 
     /// CreateGlobalVariable - Create a new descriptor for the specified global.
     DIGlobalVariable
@@ -433,17 +492,13 @@ namespace llvm {
                          const std::string &LinkageName, 
                          DICompileUnit CompileUnit,
                          unsigned LineNo, DIType Type, bool isLocalToUnit,
-                         bool isDefinition, llvm::GlobalVariable *GV,
-                         const std::string *FileName = 0,
-                         const std::string *Directory = 0);
+                         bool isDefinition, llvm::GlobalVariable *GV);
 
     /// CreateVariable - Create a new descriptor for the specified variable.
     DIVariable CreateVariable(unsigned Tag, DIDescriptor Context,
                               const std::string &Name,
                               DICompileUnit CompileUnit, unsigned LineNo,
-                              DIType Type,
-                              const std::string *FileName = 0,
-                              const std::string *Directory = 0);
+                              DIType Type);
 
     /// CreateBlock - This creates a descriptor for a lexical block with the
     /// specified parent context.
@@ -472,7 +527,6 @@ namespace llvm {
   private:
     Constant *GetTagConstant(unsigned TAG);
     Constant *GetStringConstant(const std::string &String);
-    DIAnchor GetOrCreateAnchor(unsigned TAG, const char *Name);
 
     /// getCastToEmpty - Return the descriptor as a Constant* with type '{}*'.
     Constant *getCastToEmpty(DIDescriptor D);
@@ -489,6 +543,60 @@ namespace llvm {
   /// Finds the dbg.declare intrinsic corresponding to this value if any.
   /// It looks through pointer casts too.
   const DbgDeclareInst *findDbgDeclare(const Value *V, bool stripCasts = true);
+
+  /// Find the debug info descriptor corresponding to this global variable.
+  Value *findDbgGlobalDeclare(GlobalVariable *V);
+
+  bool getLocationInfo(const Value *V, std::string &DisplayName, std::string &Type, 
+                       unsigned &LineNo, std::string &File, std::string &Dir); 
+
+  /// CollectDebugInfoAnchors - Collect debugging information anchors.
+  void CollectDebugInfoAnchors(Module &M,
+                               SmallVector<GlobalVariable *, 2> &CompileUnits,
+                               SmallVector<GlobalVariable *, 4> &GlobalVars,
+                               SmallVector<GlobalVariable *, 4> &Subprograms);
+
+  /// isValidDebugInfoIntrinsic - Return true if SPI is a valid debug 
+  /// info intrinsic.
+  bool isValidDebugInfoIntrinsic(DbgStopPointInst &SPI, 
+                                 CodeGenOpt::Level OptLev);
+
+  /// isValidDebugInfoIntrinsic - Return true if FSI is a valid debug 
+  /// info intrinsic.
+  bool isValidDebugInfoIntrinsic(DbgFuncStartInst &FSI,
+                                 CodeGenOpt::Level OptLev);
+
+  /// isValidDebugInfoIntrinsic - Return true if RSI is a valid debug 
+  /// info intrinsic.
+  bool isValidDebugInfoIntrinsic(DbgRegionStartInst &RSI,
+                                 CodeGenOpt::Level OptLev);
+
+  /// isValidDebugInfoIntrinsic - Return true if REI is a valid debug 
+  /// info intrinsic.
+  bool isValidDebugInfoIntrinsic(DbgRegionEndInst &REI,
+                                 CodeGenOpt::Level OptLev);
+
+  /// isValidDebugInfoIntrinsic - Return true if DI is a valid debug 
+  /// info intrinsic.
+  bool isValidDebugInfoIntrinsic(DbgDeclareInst &DI,
+                                 CodeGenOpt::Level OptLev);
+
+  /// ExtractDebugLocation - Extract debug location information 
+  /// from llvm.dbg.stoppoint intrinsic.
+  DebugLoc ExtractDebugLocation(DbgStopPointInst &SPI,
+                                DebugLocTracker &DebugLocInfo);
+
+  /// ExtractDebugLocation - Extract debug location information 
+  /// from llvm.dbg.func_start intrinsic.
+  DebugLoc ExtractDebugLocation(DbgFuncStartInst &FSI,
+                                DebugLocTracker &DebugLocInfo);
+
+  /// isInlinedFnStart - Return true if FSI is starting an inlined function.
+  bool isInlinedFnStart(DbgFuncStartInst &FSI, const Function *CurrentFn);
+
+  /// isInlinedFnEnd - Return true if REI is ending an inlined function.
+  bool isInlinedFnEnd(DbgRegionEndInst &REI, const Function *CurrentFn);
+
 } // end namespace llvm
 
 #endif