Extend ScalarEvolution's multiple-exit support to compute exact

[oota-llvm.git] / include / llvm / Analysis / DebugInfo.h

diff --git a/include/llvm/Analysis/DebugInfo.h b/include/llvm/Analysis/DebugInfo.h
index c6f09283bd3da1fd742dd1d72f93e643adfc7639..42a522500fd60dc6830e372ac8150534044e6b7b 100644 (file)
--- a/include/llvm/Analysis/DebugInfo.h
+++ b/include/llvm/Analysis/DebugInfo.h
@@ -8,13 +8,16 @@
 //===----------------------------------------------------------------------===//
 //
 // 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_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/Support/Dwarf.h"
@@ -33,7 +36,7 @@ namespace llvm {
 
   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
@@ -55,12 +58,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,12 +73,18 @@ namespace llvm {
       return getUnsignedField(0) & ~LLVMDebugVersionMask;
     }
 
+    /// ValidDebugInfo - Return true if V represents valid debug info value.
+    static bool ValidDebugInfo(Value *V, CodeGenOpt::Level OptLevel);
+
+    /// dump - print descriptor.
+    void dump() const;
   };
 
   /// DIAnchor - A wrapper for various anchor descriptors.
   class DIAnchor : public DIDescriptor {
   public:
-    explicit DIAnchor(GlobalVariable *GV = 0);
+    explicit DIAnchor(GlobalVariable *GV = 0)
+      : DIDescriptor(GV, dwarf::DW_TAG_anchor) {}
 
     unsigned getAnchorTag() const { return getUnsignedField(1); }
   };
@@ -83,7 +92,8 @@ namespace llvm {
   /// 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,7 +113,8 @@ 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); }
     const std::string &getFilename(std::string &F) const {
@@ -144,7 +155,8 @@ 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) {}
 
     const std::string &getName(std::string &F) const {
       return getStringField(1, F);
@@ -214,7 +226,9 @@ namespace llvm {
   /// 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); }
 
     /// dump - print basic type.
@@ -228,7 +242,12 @@ 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); }
 
     /// getOriginalTypeSize - If this type is derived from a base type then
@@ -243,7 +262,12 @@ 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); }
     unsigned getRunTimeLang() const { return getUnsignedField(11); }
 
@@ -301,20 +325,41 @@ namespace llvm {
   /// DISubprogram - This is a wrapper for a subprogram (e.g. a function).
   class DISubprogram : public DIGlobal {
   public:
-    explicit DISubprogram(GlobalVariable *GV = 0);
+    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); }
 
     /// Verify - Verify that a global variable descriptor is well formed.
@@ -328,7 +373,11 @@ namespace llvm {
   /// 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); }
     const std::string &getName(std::string &F) const {
@@ -351,8 +400,9 @@ namespace llvm {
   /// 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); }
   };