Changing model for the construction of debug information.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26016 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 331 insertions, 100 deletions

diff --git a/include/llvm/CodeGen/DwarfWriter.h b/include/llvm/CodeGen/DwarfWriter.h
index c98dbbce39..841a029d60 100644
--- a/include/llvm/CodeGen/DwarfWriter.h
+++ b/include/llvm/CodeGen/DwarfWriter.h
@@ -33,7 +33,7 @@ namespace llvm {
   // Forward declarations.
   //
   class AsmPrinter;
-  class CompileUnitWrapper;
+  class CompileUnitDesc;
   class DIE;
   class DwarfWriter; 
   class DWContext;
@@ -657,7 +657,7 @@ private:
 
     /// NewCompileUnit - Create new compile unit information.
     ///
-    DIE *NewCompileUnit(const CompileUnitWrapper &CompileUnit);
+    DIE *NewCompileUnit(const CompileUnitDesc *CompileUnit);
 
     /// EmitInitial - Emit initial Dwarf declarations.
     ///
diff --git a/include/llvm/CodeGen/MachineDebugInfo.h b/include/llvm/CodeGen/MachineDebugInfo.h
index fe12802dcd..a04f778c16 100644
--- a/include/llvm/CodeGen/MachineDebugInfo.h
+++ b/include/llvm/CodeGen/MachineDebugInfo.h
@@ -17,160 +17,385 @@
 // The following information can be retrieved from the MachineDebugInfo.
 //
 //  -- Source directories - Directories are uniqued based on their canonical
-//     string and assigned a sequential numeric ID (base 1.)  A directory ID - 1
-//     provides the index of directory information in a queried directory list.
+//     string and assigned a sequential numeric ID (base 1.)
 //  -- Source files - Files are also uniqued based on their name and directory
-//     ID.  A file ID is sequential number (base 1.)  A file ID - 1 provides the
-//     index of source information in a queried file list.
+//     ID.  A file ID is sequential number (base 1.)
 //  -- Source line coorespondence - A vector of file ID, line#, column# triples.
 //     A DEBUG_LOCATION instruction is generated  by the DAG Legalizer
 //     corresponding to each entry in the source line list.  This allows a debug
-//     information emitter to generate labels to map code addressed to debug
-//     tables.
+//     emitter to generate labels referenced by degug information tables.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_MACHINEDEBUGINFO_H
 #define LLVM_CODEGEN_MACHINEDEBUGINFO_H
 
-#include "llvm/Pass.h"
+#include "llvm/Support/Dwarf.h"
 #include "llvm/ADT/UniqueVector.h"
+#include "llvm/Pass.h"
+#include "llvm/User.h"
+
 #include <string>
+#include <set>
 
 namespace llvm {
 
+//===----------------------------------------------------------------------===//
 // Forward declarations.
-class ConstantStruct;
+class DebugInfoDesc;
 class GlobalVariable;
 class Module;
+class PointerType;
+class StructType;
 
 //===----------------------------------------------------------------------===//
-/// DebugInfoWrapper - This class is the base class for debug info wrappers.
+// Debug info constants.
+enum {
+  LLVMDebugVersion = 1,                 // Current version of debug information.
+  DIInvalid = ~0U,                      // Invalid result indicator.
+  
+  // DebugInfoDesc type identifying tags.
+  // FIXME - Change over with gcc4.
+#if 1
+  DI_TAG_compile_unit = DW_TAG_compile_unit,
+  DI_TAG_global_variable = DW_TAG_variable,
+  DI_TAG_subprogram = DW_TAG_subprogram
+#else
+  DI_TAG_compile_unit = 1,
+  DI_TAG_global_variable,
+  DI_TAG_subprogram
+#endif
+};
+
+//===----------------------------------------------------------------------===//
+/// DIApplyManager - Subclasses of this class apply steps to each of the fields
+/// in the supplied DebugInfoDesc.
+class DIApplyManager {
+public:
+  DIApplyManager() {}
+  virtual ~DIApplyManager() {}
+  
+  
+  /// ApplyToFields - Target the manager to each field of the debug information
+  /// descriptor.
+  void ApplyToFields(DebugInfoDesc *DD);
+  
+  /// Apply - Subclasses override each of these methods to perform the
+  /// appropriate action for the type of field.
+  virtual void Apply(int &Field) = 0;
+  virtual void Apply(unsigned &Field) = 0;
+  virtual void Apply(bool &Field) = 0;
+  virtual void Apply(std::string &Field) = 0;
+  virtual void Apply(DebugInfoDesc *&Field) = 0;
+  virtual void Apply(GlobalVariable *&Field) = 0;
+};
+
+//===----------------------------------------------------------------------===//
+/// DebugInfoDesc - This class is the base class for debug info descriptors.
 ///
-class DebugInfoWrapper {
+class DebugInfoDesc {
+private:
+  unsigned Tag;                         // Content indicator.  Dwarf values are
+                                        // used but that does not limit use to
+                                        // Dwarf writers.
+  
 protected:
-  GlobalVariable *GV;                   // "llvm.db" global
-  ConstantStruct *IC;                   // Initializer constant.
+  DebugInfoDesc(unsigned T) : Tag(T) {}
   
 public:
-  DebugInfoWrapper(GlobalVariable *G);
+  virtual ~DebugInfoDesc() {}
+
+  // Accessors
+  unsigned getTag()          const { return Tag; }
   
-  /// getGlobal - Return the "llvm.db" global.
-  ///
-  GlobalVariable *getGlobal() const { return GV; }
+  /// TagFromGlobal - Returns the Tag number from a debug info descriptor
+  /// GlobalVariable.
+  static unsigned TagFromGlobal(GlobalVariable *GV, bool Checking = false);
 
-  /// operator== - Used by Uniquevector to locate entry.
+  /// DescFactory - Create an instance of debug info descriptor based on Tag.
+  /// Return NULL if not a recognized Tag.
+  static DebugInfoDesc *DescFactory(unsigned Tag);
+  
+  //===--------------------------------------------------------------------===//
+  // Subclasses should supply the following static methods.
+  
+  // Implement isa/cast/dyncast.
+  static bool classof(const DebugInfoDesc *)  { return true; }
+  
+  //===--------------------------------------------------------------------===//
+  // Subclasses should supply the following virtual methods.
+  
+  /// ApplyToFields - Target the apply manager to the fields of the descriptor.
   ///
-  bool operator==(const DebugInfoWrapper &DI) const { return IC == DI.IC; }
+  virtual void ApplyToFields(DIApplyManager *Mgr) = 0;
 
-  /// operator< - Used by Uniquevector to locate entry.
+  /// TypeString - Return a string used to compose globalnames and labels.
   ///
-  bool operator<(const DebugInfoWrapper &DI) const { return IC < DI.IC; }
+  virtual const char *TypeString() const = 0;
+  
+#ifndef NDEBUG
+  virtual void dump() = 0;
+#endif
 };
 
 
 //===----------------------------------------------------------------------===//
-/// CompileUnitWrapper - This class wraps a "lldb.compile_unit" global to
-/// provide easy access to its attributes.
-class CompileUnitWrapper : public DebugInfoWrapper {
-private:
-  // Operand indices.
-  enum {
-    Tag_op,
-    Version_op,
-    Language_op,
-    FileName_op,
-    Directory_op,
-    Producer_op,
-    Anchor_op, // ignored
-    N_op
-  };
+/// CompileUnitDesc - This class packages debug information associated with a 
+/// source/header file.
+class CompileUnitDesc : public DebugInfoDesc {
+private:  
+  unsigned DebugVersion;                // LLVM debug version when produced.
+  unsigned Language;                    // Language number (ex. DW_LANG_C89.)
+  std::string FileName;                 // Source file name.
+  std::string Directory;                // Source file directory.
+  std::string Producer;                 // Compiler string.
+  GlobalVariable *TransUnit;            // Translation unit - ignored.
   
 public:
-  CompileUnitWrapper(GlobalVariable *G);
+  CompileUnitDesc()
+  : DebugInfoDesc(DI_TAG_compile_unit)
+  , DebugVersion(LLVMDebugVersion)
+  , Language(0)
+  , FileName("")
+  , Directory("")
+  , Producer("")
+  , TransUnit(NULL)
+  {}
   
-  /// getGlobal - Return the "lldb.compile_unit" global.
-  ///
-  GlobalVariable *getGlobal() const { return GV; }
-
-  /// getTag - Return the compile unit's tag number.  Currently DW_TAG_variable,
-  /// DW_TAG_subprogram or DW_TAG_compile_unit.
-  unsigned getTag() const;
+  // Accessors
+  unsigned getDebugVersion()              const { return DebugVersion; }
+  unsigned getLanguage()                  const { return Language; }
+  const std::string &getFileName()        const { return FileName; }
+  const std::string &getDirectory()       const { return Directory; }
+  const std::string &getProducer()        const { return Producer; }
+  void setLanguage(unsigned L)                  { Language = L; }
+  void setFileName(const std::string &FN)       { FileName = FN; }
+  void setDirectory(const std::string &D)       { Directory = D; }
+  void setProducer(const std::string &P)        { Producer = P; }
+  // FIXME - Need translation unit getter/setter.
 
-  /// isCorrectDebugVersion - Return true if is the correct llvm debug version.
-  /// Currently the value is 0 (zero.)  If the value is is not correct then
-  /// ignore all debug information.
-  bool isCorrectDebugVersion() const;
+  // Implement isa/cast/dyncast.
+  static bool classof(const CompileUnitDesc *) { return true; }
+  static bool classof(const DebugInfoDesc *D) {
+    return D->getTag() == DI_TAG_compile_unit;
+  }
   
-  /// getLanguage - Return the compile unit's language number (ex. DW_LANG_C89.)
-  ///
-  unsigned getLanguage() const;
+  /// DebugVersionFromGlobal - Returns the version number from a compile unit
+  /// GlobalVariable.
+  static unsigned DebugVersionFromGlobal(GlobalVariable *GV,
+                                         bool Checking = false);
   
-  /// getFileName - Return the compile unit's file name.
+  /// ApplyToFields - Target the apply manager to the fields of the 
+  /// CompileUnitDesc.
+  virtual void ApplyToFields(DIApplyManager *Mgr);
+
+  /// TypeString - Return a string used to compose globalnames and labels.
   ///
-  const std::string getFileName() const;
+  virtual const char *TypeString() const;
+    
+#ifndef NDEBUG
+  virtual void dump();
+#endif
+};
+
+//===----------------------------------------------------------------------===//
+/// GlobalVariableDesc - This class packages debug information associated with a
+/// GlobalVariable.
+class GlobalVariableDesc : public DebugInfoDesc {
+private:
+  DebugInfoDesc *Context;               // Context debug descriptor.
+  std::string Name;                     // Global name.
+  GlobalVariable *TransUnit;            // Translation unit - ignored.
+  // FIXME - Use a descriptor.
+  GlobalVariable *TyDesc;               // Type debug descriptor.
+  bool IsStatic;                        // Is the global a static.
+  bool IsDefinition;                    // Is the global defined in context.
+  GlobalVariable *Global;               // llvm global.
   
-  /// getDirectory - Return the compile unit's file directory.
-  ///
-  const std::string getDirectory() const;
+public:
+  GlobalVariableDesc()
+  : DebugInfoDesc(DI_TAG_global_variable)
+  , Context(0)
+  , Name("")
+  , TransUnit(NULL)
+  , TyDesc(NULL)
+  , IsStatic(false)
+  , IsDefinition(false)
+  , Global(NULL)
+  {}
   
-  /// getProducer - Return the compile unit's generator name.
+  // Accessors
+  DebugInfoDesc *getContext()                const { return Context; }
+  const std::string &getName()               const { return Name; }
+  bool isStatic()                            const { return IsStatic; }
+  bool isDefinition()                        const { return IsDefinition; }
+  GlobalVariable *getGlobalVariable()        const { return Global; }
+  void setName(const std::string &N)               { Name = N; }
+  void setIsStatic(bool IS)                        { IsStatic = IS; }
+  void setIsDefinition(bool ID)                    { IsDefinition = ID; }
+  void setGlobalVariable(GlobalVariable *GV)       { Global = GV; }
+  // FIXME - Other getters/setters.
+  
+  // Implement isa/cast/dyncast.
+  static bool classof(const GlobalVariableDesc *)  { return true; }
+  static bool classof(const DebugInfoDesc *D) {
+    return D->getTag() == DI_TAG_global_variable;
+  }
+  
+  /// ApplyToFields - Target the apply manager to the fields of the 
+  /// GlobalVariableDesc.
+  virtual void ApplyToFields(DIApplyManager *Mgr);
+
+  /// TypeString - Return a string used to compose globalnames and labels.
   ///
-  const std::string getProducer() const;
+  virtual const char *TypeString() const;
+
+#ifndef NDEBUG
+  virtual void dump();
+#endif
 };
 
 //===----------------------------------------------------------------------===//
-/// GlobalWrapper - This class wraps a "lldb.global" global to provide easy
-/// access to its attributes.
-class GlobalWrapper : public DebugInfoWrapper {
+/// SubprogramDesc - This class packages debug information associated with a
+/// subprogram/function.
+class SubprogramDesc : public DebugInfoDesc {
 private:
-  // Operand indices.
-  enum {
-    Tag_op,
-    Context_op,
-    Name_op,
-    Anchor_op, // ignored
-    Type_op,
-    Static_op,
-    Definition_op,
-    GlobalVariable_op,
-    N_op
-  };
+  DebugInfoDesc *Context;               // Context debug descriptor.
+  std::string Name;                     // Subprogram name.
+  GlobalVariable *TransUnit;            // Translation unit - ignored.
+  // FIXME - Use a descriptor.
+  GlobalVariable *TyDesc;               // Type debug descriptor.
+  bool IsStatic;                        // Is the subprogram a static.
+  bool IsDefinition;                    // Is the subprogram defined in context.
   
 public:
-  GlobalWrapper(GlobalVariable *G);
+  SubprogramDesc()
+  : DebugInfoDesc(DI_TAG_subprogram)
+  , Context(0)
+  , Name("")
+  , TransUnit(NULL)
+  , TyDesc(NULL)
+  , IsStatic(false)
+  , IsDefinition(false)
+  {}
   
-  /// getGlobal - Return the "lldb.global" global.
-  ///
-  GlobalVariable *getGlobal() const { return GV; }
+  // Accessors
+  DebugInfoDesc *getContext()                const { return Context; }
+  const std::string &getName()               const { return Name; }
+  bool isStatic()                            const { return IsStatic; }
+  bool isDefinition()                        const { return IsDefinition; }
+  void setName(const std::string &N)               { Name = N; }
+  void setIsStatic(bool IS)                        { IsStatic = IS; }
+  void setIsDefinition(bool ID)                    { IsDefinition = ID; }
+  // FIXME - Other getters/setters.
+  
+  // Implement isa/cast/dyncast.
+  static bool classof(const SubprogramDesc *)  { return true; }
+  static bool classof(const DebugInfoDesc *D) {
+    return D->getTag() == DI_TAG_subprogram;
+  }
+  
+  /// ApplyToFields - Target the apply manager to the fields of the 
+  /// SubprogramDesc.
+  virtual void ApplyToFields(DIApplyManager *Mgr);
 
-  /// getContext - Return the "lldb.compile_unit" context global.
+  /// TypeString - Return a string used to compose globalnames and labels.
   ///
-  GlobalVariable *getContext() const;
+  virtual const char *TypeString() const;
 
-  /// getTag - Return the global's tag number.  Currently should be 
-  /// DW_TAG_variable or DW_TAG_subprogram.
-  unsigned getTag() const;
+#ifndef NDEBUG
+  virtual void dump();
+#endif
+};
+
+//===----------------------------------------------------------------------===//
+/// DIDeserializer - This class is responsible for casting GlobalVariables
+/// into DebugInfoDesc objects.
+class DIDeserializer {
+private:
+  Module *M;                            // Definition space module.
+  unsigned DebugVersion;                // Version of debug information in use.
+  std::map<GlobalVariable *, DebugInfoDesc *> GlobalDescs;
+                                        // Previously defined gloabls.
+  
+public:
+  DIDeserializer() : M(NULL), DebugVersion(LLVMDebugVersion) {}
+  ~DIDeserializer() {}
+  
+  // Accessors
+  Module *getModule()        const { return M; };
+  void setModule(Module *module)   { M = module; }
+  unsigned getDebugVersion() const { return DebugVersion; }
   
-  /// getName - Return the name of the global.
+  /// Deserialize - Reconstitute a GlobalVariable into it's component
+  /// DebugInfoDesc objects.
+  DebugInfoDesc *Deserialize(Value *V);
+  DebugInfoDesc *Deserialize(GlobalVariable *GV);
+};
+
+//===----------------------------------------------------------------------===//
+/// DISerializer - This class is responsible for casting DebugInfoDesc objects
+/// into GlobalVariables.
+class DISerializer {
+private:
+  Module *M;                            // Definition space module.
+  PointerType *StrPtrTy;                // A "sbyte *" type.  Created lazily.
+  PointerType *EmptyStructPtrTy;        // A "{ }*" type.  Created lazily.
+  std::map<unsigned, StructType *> TagTypes;
+                                        // Types per Tag.  Created lazily.
+  std::map<DebugInfoDesc *, GlobalVariable *> DescGlobals;
+                                        // Previously defined descriptors.
+  std::map<const std::string, GlobalVariable*> StringCache;
+                                        // Previously defined strings.
+public:
+  DISerializer() : M(NULL) {}
+  ~DISerializer() {}
+  
+  // Accessors
+  Module *getModule()        const { return M; };
+  void setModule(Module *module)  { M = module; }
+
+  /// getStrPtrType - Return a "sbyte *" type.
   ///
-  const std::string getName() const;
+  const PointerType *getStrPtrType();
   
-  /// getType - Return the type of the global.
+  /// getEmptyStructPtrType - Return a "{ }*" type.
   ///
-  const GlobalVariable *getType() const;
- 
-  /// isStatic - Return true if the global is static.
+  const PointerType *getEmptyStructPtrType();
+  
+  /// getTagType - Return the type describing the specified descriptor (via
+  /// tag.)
+  const StructType *getTagType(DebugInfoDesc *DD);
+  
+  /// getString - Construct the string as constant string global.
   ///
-  bool isStatic() const;
+  GlobalVariable *getString(const std::string &String);
+  
+  /// Serialize - Recursively cast the specified descriptor into a
+  /// GlobalVariable so that it can be serialized to a .bc or .ll file.
+  GlobalVariable *Serialize(DebugInfoDesc *DD);
+};
 
-  /// isDefinition - Return true if the global is a definition.
-  ///
-  bool isDefinition() const;
+//===----------------------------------------------------------------------===//
+/// DIVerifier - This class is responsible for verifying the given network of
+/// GlobalVariables are valid as DebugInfoDesc objects.
+class DIVerifier {
+private:
+  unsigned DebugVersion;                // Version of debug information in use.
+  std::set<GlobalVariable *> Visited;   // Tracks visits during recursion.
+  std::map<unsigned, unsigned> Counts;  // Count of fields per Tag type.
+
+  /// markVisited - Return true if the GlobalVariable hase been "seen" before.
+  /// Mark markVisited otherwise.
+  bool markVisited(GlobalVariable *GV);
   
-  /// getGlobalVariable - Return the global variable (tag == DW_TAG_variable.)
-  ///
-  GlobalVariable *getGlobalVariable() const;
+public:
+  DIVerifier() : DebugVersion(LLVMDebugVersion) {}
+  ~DIVerifier() {}
+  
+  /// Verify - Return true if the GlobalVariable appears to be a valid
+  /// serialization of a DebugInfoDesc.
+  bool Verify(GlobalVariable *GV);
 };
 
 //===----------------------------------------------------------------------===//
@@ -228,8 +453,14 @@ public:
 ///
 class MachineDebugInfo : public ImmutablePass {
 private:
+  // Debug indforma
+  // Use the same serializer/deserializer/verifier for the module.
+  DISerializer SR;
+  DIDeserializer DR;
+  DIVerifier VR;
+
   // CompileUnits - Uniquing vector for compile units.
-  UniqueVector<CompileUnitWrapper> CompileUnits;
+  UniqueVector<CompileUnitDesc *> CompileUnits;
   
   // Directories - Uniquing vector for directories.
   UniqueVector<std::string> Directories;
@@ -300,11 +531,11 @@ public:
 
   /// getCompileUnits - Return a vector of debug compile units.
   ///
-  const UniqueVector<CompileUnitWrapper> getCompileUnits() const;
+  const UniqueVector<CompileUnitDesc *> getCompileUnits() const;
 
-  /// getGlobalVariables - Return a vector of debug global variables.
+  /// getGlobalVariables - Return a vector of debug GlobalVariables.
   ///
-  static std::vector<GlobalWrapper> getGlobalVariables(Module &M);
+  std::vector<GlobalVariableDesc *> getGlobalVariables(Module &M);
 
 }; // End class MachineDebugInfo