X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FIR%2FDebugInfo.h;h=5429648ade2c580bdb1920ce8913ded51e9c6b91;hb=0ed5091742d9e6603b30e7270a8eab0350e962dd;hp=eede59d725d64c8c791564d796b3ccbddc6b9879;hpb=20b39c653c3db539a728cd67faf7b6026619e4e2;p=oota-llvm.git

diff --git a/include/llvm/IR/DebugInfo.h b/include/llvm/IR/DebugInfo.h
index eede59d725d..5429648ade2 100644
--- a/include/llvm/IR/DebugInfo.h
+++ b/include/llvm/IR/DebugInfo.h
@@ -29,378 +29,23 @@
 #include <iterator>
 
 namespace llvm {
-class BasicBlock;
-class Constant;
-class Function;
-class GlobalVariable;
 class Module;
-class Type;
-class Value;
 class DbgDeclareInst;
 class DbgValueInst;
-class Instruction;
-class Metadata;
-class MDNode;
-class MDString;
-class NamedMDNode;
-class LLVMContext;
-class raw_ostream;
-
-class DIFile;
-class DISubprogram;
-class DILexicalBlock;
-class DILexicalBlockFile;
-class DIVariable;
-class DIType;
-class DIScope;
-class DIObjCProperty;
 
 /// \brief Maps from type identifier to the actual MDNode.
-typedef DenseMap<const MDString *, MDNode *> DITypeIdentifierMap;
-
-#define DECLARE_SIMPLIFY_DESCRIPTOR(DESC)                                      \
-  class DESC;                                                                  \
-  template <> struct simplify_type<const DESC>;                                \
-  template <> struct simplify_type<DESC>;
-DECLARE_SIMPLIFY_DESCRIPTOR(DISubrange)
-DECLARE_SIMPLIFY_DESCRIPTOR(DIEnumerator)
-DECLARE_SIMPLIFY_DESCRIPTOR(DIScope)
-DECLARE_SIMPLIFY_DESCRIPTOR(DIType)
-DECLARE_SIMPLIFY_DESCRIPTOR(DIBasicType)
-DECLARE_SIMPLIFY_DESCRIPTOR(DIDerivedType)
-DECLARE_SIMPLIFY_DESCRIPTOR(DICompositeType)
-DECLARE_SIMPLIFY_DESCRIPTOR(DISubroutineType)
-DECLARE_SIMPLIFY_DESCRIPTOR(DIFile)
-DECLARE_SIMPLIFY_DESCRIPTOR(DICompileUnit)
-DECLARE_SIMPLIFY_DESCRIPTOR(DISubprogram)
-DECLARE_SIMPLIFY_DESCRIPTOR(DILexicalBlock)
-DECLARE_SIMPLIFY_DESCRIPTOR(DILexicalBlockFile)
-DECLARE_SIMPLIFY_DESCRIPTOR(DINameSpace)
-DECLARE_SIMPLIFY_DESCRIPTOR(DITemplateTypeParameter)
-DECLARE_SIMPLIFY_DESCRIPTOR(DITemplateValueParameter)
-DECLARE_SIMPLIFY_DESCRIPTOR(DIGlobalVariable)
-DECLARE_SIMPLIFY_DESCRIPTOR(DIVariable)
-DECLARE_SIMPLIFY_DESCRIPTOR(DIExpression)
-DECLARE_SIMPLIFY_DESCRIPTOR(DILocation)
-DECLARE_SIMPLIFY_DESCRIPTOR(DIObjCProperty)
-DECLARE_SIMPLIFY_DESCRIPTOR(DIImportedEntity)
-#undef DECLARE_SIMPLIFY_DESCRIPTOR
-
-typedef DebugNodeArray DIArray;
-typedef MDTypeRefArray DITypeArray;
-typedef DebugNodeRef DIDescriptorRef;
-typedef MDScopeRef DIScopeRef;
-typedef MDTypeRef DITypeRef;
-
-class DISubrange {
-  MDSubrange *N;
-
-public:
-  DISubrange(const MDSubrange *N = nullptr) : N(const_cast<MDSubrange *>(N)) {}
-
-  operator MDSubrange *() const { return N; }
-  MDSubrange *operator->() const { return N; }
-  MDSubrange &operator*() const { return *N; }
-};
-
-class DIEnumerator {
-  MDEnumerator *N;
-
-public:
-  DIEnumerator(const MDEnumerator *N = nullptr)
-      : N(const_cast<MDEnumerator *>(N)) {}
-
-  operator MDEnumerator *() const { return N; }
-  MDEnumerator *operator->() const { return N; }
-  MDEnumerator &operator*() const { return *N; }
-};
-
-class DIScope {
-  MDScope *N;
-
-public:
-  DIScope(const MDScope *N = nullptr) : N(const_cast<MDScope *>(N)) {}
-
-  operator MDScope *() const { return N; }
-  MDScope *operator->() const { return N; }
-  MDScope &operator*() const { return *N; }
-};
-
-class DIType {
-  MDType *N;
-
-public:
-  DIType(const MDType *N = nullptr) : N(const_cast<MDType *>(N)) {}
-
-  operator DIScope() const { return N; }
-  operator MDType *() const { return N; }
-  MDType *operator->() const { return N; }
-  MDType &operator*() const { return *N; }
-};
-
-class DIBasicType {
-  MDBasicType *N;
-
-public:
-  DIBasicType(const MDBasicType *N = nullptr)
-      : N(const_cast<MDBasicType *>(N)) {}
-
-  operator DIType() const { return N; }
-  operator MDBasicType *() const { return N; }
-  MDBasicType *operator->() const { return N; }
-  MDBasicType &operator*() const { return *N; }
-};
-
-class DIDerivedType {
-  MDDerivedTypeBase *N;
-
-public:
-  DIDerivedType(const MDDerivedTypeBase *N = nullptr)
-      : N(const_cast<MDDerivedTypeBase *>(N)) {}
-
-  operator DIType() const { return N; }
-  operator MDDerivedTypeBase *() const { return N; }
-  MDDerivedTypeBase *operator->() const { return N; }
-  MDDerivedTypeBase &operator*() const { return *N; }
-};
-
-class DICompositeType {
-  MDCompositeTypeBase *N;
-
-public:
-  DICompositeType(const MDCompositeTypeBase *N = nullptr)
-      : N(const_cast<MDCompositeTypeBase *>(N)) {}
-
-  operator DIType() const { return N; }
-  operator MDCompositeTypeBase *() const { return N; }
-  MDCompositeTypeBase *operator->() const { return N; }
-  MDCompositeTypeBase &operator*() const { return *N; }
-};
-
-class DISubroutineType {
-  MDSubroutineType *N;
-
-public:
-  DISubroutineType(const MDSubroutineType *N = nullptr)
-      : N(const_cast<MDSubroutineType *>(N)) {}
-
-  operator DIType() const { return N; }
-  operator DICompositeType() const { return N; }
-  operator MDSubroutineType *() const { return N; }
-  MDSubroutineType *operator->() const { return N; }
-  MDSubroutineType &operator*() const { return *N; }
-};
-
-class DIFile {
-  MDFile *N;
-
-public:
-  DIFile(const MDFile *N = nullptr) : N(const_cast<MDFile *>(N)) {}
-
-  operator DIScope() const { return N; }
-  operator MDFile *() const { return N; }
-  MDFile *operator->() const { return N; }
-  MDFile &operator*() const { return *N; }
-};
-
-class DICompileUnit {
-  MDCompileUnit *N;
-
-public:
-  DICompileUnit(const MDCompileUnit *N = nullptr)
-      : N(const_cast<MDCompileUnit *>(N)) {}
-
-  operator DIScope() const { return N; }
-  operator MDCompileUnit *() const { return N; }
-  MDCompileUnit *operator->() const { return N; }
-  MDCompileUnit &operator*() const { return *N; }
-};
-
-class DISubprogram {
-  MDSubprogram *N;
-
-public:
-  DISubprogram(const MDSubprogram *N = nullptr)
-      : N(const_cast<MDSubprogram *>(N)) {}
-
-  operator DIScope() const { return N; }
-  operator MDSubprogram *() const { return N; }
-  MDSubprogram *operator->() const { return N; }
-  MDSubprogram &operator*() const { return *N; }
-};
-
-class DILexicalBlock {
-  MDLexicalBlockBase *N;
-
-public:
-  DILexicalBlock(const MDLexicalBlockBase *N = nullptr)
-      : N(const_cast<MDLexicalBlockBase *>(N)) {}
-
-  operator MDLexicalBlockBase *() const { return N; }
-  MDLexicalBlockBase *operator->() const { return N; }
-  MDLexicalBlockBase &operator*() const { return *N; }
-};
-
-class DILexicalBlockFile {
-  MDLexicalBlockFile *N;
-
-public:
-  DILexicalBlockFile(const MDLexicalBlockFile *N = nullptr)
-      : N(const_cast<MDLexicalBlockFile *>(N)) {}
-
-  operator MDLexicalBlockFile *() const { return N; }
-  MDLexicalBlockFile *operator->() const { return N; }
-  MDLexicalBlockFile &operator*() const { return *N; }
-};
-
-class DINameSpace {
-  MDNamespace *N;
-
-public:
-  DINameSpace(const MDNamespace *N = nullptr)
-      : N(const_cast<MDNamespace *>(N)) {}
-
-  operator DIScope() const { return N; }
-  operator MDNamespace *() const { return N; }
-  MDNamespace *operator->() const { return N; }
-  MDNamespace &operator*() const { return *N; }
-};
-
-class DITemplateTypeParameter {
-  MDTemplateTypeParameter *N;
-
-public:
-  DITemplateTypeParameter(const MDTemplateTypeParameter *N = nullptr)
-      : N(const_cast<MDTemplateTypeParameter *>(N)) {}
-
-  operator MDTemplateTypeParameter *() const { return N; }
-  MDTemplateTypeParameter *operator->() const { return N; }
-  MDTemplateTypeParameter &operator*() const { return *N; }
-};
-
-class DITemplateValueParameter {
-  MDTemplateValueParameter *N;
-
-public:
-  DITemplateValueParameter(const MDTemplateValueParameter *N = nullptr)
-      : N(const_cast<MDTemplateValueParameter *>(N)) {}
-
-  operator MDTemplateValueParameter *() const { return N; }
-  MDTemplateValueParameter *operator->() const { return N; }
-  MDTemplateValueParameter &operator*() const { return *N; }
-};
-
-class DIGlobalVariable {
-  MDGlobalVariable *N;
-
-public:
-  DIGlobalVariable(const MDGlobalVariable *N = nullptr)
-      : N(const_cast<MDGlobalVariable *>(N)) {}
-
-  operator MDGlobalVariable *() const { return N; }
-  MDGlobalVariable *operator->() const { return N; }
-  MDGlobalVariable &operator*() const { return *N; }
-};
-
-class DIVariable {
-  MDLocalVariable *N;
-
-public:
-  DIVariable(const MDLocalVariable *N = nullptr)
-      : N(const_cast<MDLocalVariable *>(N)) {}
-
-  operator MDLocalVariable *() const { return N; }
-  MDLocalVariable *operator->() const { return N; }
-  MDLocalVariable &operator*() const { return *N; }
-};
-
-class DIExpression {
-  MDExpression *N;
-
-public:
-  DIExpression(const MDExpression *N = nullptr)
-      : N(const_cast<MDExpression *>(N)) {}
-
-  operator MDExpression *() const { return N; }
-  MDExpression *operator->() const { return N; }
-  MDExpression &operator*() const { return *N; }
-};
-
-class DILocation {
-  MDLocation *N;
-
-public:
-  DILocation(const MDLocation *N = nullptr) : N(const_cast<MDLocation *>(N)) {}
-
-  operator MDLocation *() const { return N; }
-  MDLocation *operator->() const { return N; }
-  MDLocation &operator*() const { return *N; }
-};
-
-class DIObjCProperty {
-  MDObjCProperty *N;
-
-public:
-  DIObjCProperty(const MDObjCProperty *N = nullptr)
-      : N(const_cast<MDObjCProperty *>(N)) {}
-
-  operator MDObjCProperty *() const { return N; }
-  MDObjCProperty *operator->() const { return N; }
-  MDObjCProperty &operator*() const { return *N; }
-};
-
-class DIImportedEntity {
-  MDImportedEntity *N;
-
-public:
-  DIImportedEntity(const MDImportedEntity *N = nullptr)
-      : N(const_cast<MDImportedEntity *>(N)) {}
-
-  operator MDImportedEntity *() const { return N; }
-  MDImportedEntity *operator->() const { return N; }
-  MDImportedEntity &operator*() const { return *N; }
-};
-
-#define SIMPLIFY_DESCRIPTOR(DESC)                                              \
-  template <> struct simplify_type<const DESC> {                               \
-    typedef Metadata *SimpleType;                                              \
-    static SimpleType getSimplifiedValue(const DESC &DI) { return DI; }        \
-  };                                                                           \
-  template <> struct simplify_type<DESC> : simplify_type<const DESC> {};
-SIMPLIFY_DESCRIPTOR(DISubrange)
-SIMPLIFY_DESCRIPTOR(DIEnumerator)
-SIMPLIFY_DESCRIPTOR(DIScope)
-SIMPLIFY_DESCRIPTOR(DIType)
-SIMPLIFY_DESCRIPTOR(DIBasicType)
-SIMPLIFY_DESCRIPTOR(DIDerivedType)
-SIMPLIFY_DESCRIPTOR(DICompositeType)
-SIMPLIFY_DESCRIPTOR(DISubroutineType)
-SIMPLIFY_DESCRIPTOR(DIFile)
-SIMPLIFY_DESCRIPTOR(DICompileUnit)
-SIMPLIFY_DESCRIPTOR(DISubprogram)
-SIMPLIFY_DESCRIPTOR(DILexicalBlock)
-SIMPLIFY_DESCRIPTOR(DILexicalBlockFile)
-SIMPLIFY_DESCRIPTOR(DINameSpace)
-SIMPLIFY_DESCRIPTOR(DITemplateTypeParameter)
-SIMPLIFY_DESCRIPTOR(DITemplateValueParameter)
-SIMPLIFY_DESCRIPTOR(DIGlobalVariable)
-SIMPLIFY_DESCRIPTOR(DIVariable)
-SIMPLIFY_DESCRIPTOR(DIExpression)
-SIMPLIFY_DESCRIPTOR(DILocation)
-SIMPLIFY_DESCRIPTOR(DIObjCProperty)
-SIMPLIFY_DESCRIPTOR(DIImportedEntity)
-#undef SIMPLIFY_DESCRIPTOR
+typedef DenseMap<const MDString *, DIType *> DITypeIdentifierMap;
 
 /// \brief Find subprogram that is enclosing this scope.
-MDSubprogram *getDISubprogram(const MDNode *Scope);
+DISubprogram *getDISubprogram(const MDNode *Scope);
 
 /// \brief Find debug info for a given function.
-/// \returns a valid DISubprogram, if found. Otherwise, it returns an empty
-/// DISubprogram.
-MDSubprogram *getDISubprogram(const Function *F);
+///
+/// \returns a valid subprogram, if found. Otherwise, return \c nullptr.
+DISubprogram *getDISubprogram(const Function *F);
 
 /// \brief Find underlying composite type.
-MDCompositeTypeBase *getDICompositeType(MDType *T);
+DICompositeTypeBase *getDICompositeType(DIType *T);
 
 /// \brief Generate map by visiting all retained types.
 DITypeIdentifierMap generateDITypeIdentifierMap(const NamedMDNode *CU_Nodes);
@@ -435,8 +80,8 @@ public:
   void processDeclare(const Module &M, const DbgDeclareInst *DDI);
   /// \brief Process DbgValueInst.
   void processValue(const Module &M, const DbgValueInst *DVI);
-  /// \brief Process DILocation.
-  void processLocation(const Module &M, const MDLocation *Loc);
+  /// \brief Process debug info location.
+  void processLocation(const Module &M, const DILocation *Loc);
 
   /// \brief Clear all lists.
   void reset();
@@ -444,23 +89,23 @@ public:
 private:
   void InitializeTypeMap(const Module &M);
 
-  void processType(MDType *DT);
-  void processSubprogram(MDSubprogram *SP);
-  void processScope(MDScope *Scope);
-  bool addCompileUnit(MDCompileUnit *CU);
-  bool addGlobalVariable(MDGlobalVariable *DIG);
-  bool addSubprogram(MDSubprogram *SP);
-  bool addType(MDType *DT);
-  bool addScope(MDScope *Scope);
+  void processType(DIType *DT);
+  void processSubprogram(DISubprogram *SP);
+  void processScope(DIScope *Scope);
+  bool addCompileUnit(DICompileUnit *CU);
+  bool addGlobalVariable(DIGlobalVariable *DIG);
+  bool addSubprogram(DISubprogram *SP);
+  bool addType(DIType *DT);
+  bool addScope(DIScope *Scope);
 
 public:
-  typedef SmallVectorImpl<MDCompileUnit *>::const_iterator
+  typedef SmallVectorImpl<DICompileUnit *>::const_iterator
       compile_unit_iterator;
-  typedef SmallVectorImpl<MDSubprogram *>::const_iterator subprogram_iterator;
-  typedef SmallVectorImpl<MDGlobalVariable *>::const_iterator
+  typedef SmallVectorImpl<DISubprogram *>::const_iterator subprogram_iterator;
+  typedef SmallVectorImpl<DIGlobalVariable *>::const_iterator
       global_variable_iterator;
-  typedef SmallVectorImpl<MDType *>::const_iterator type_iterator;
-  typedef SmallVectorImpl<MDScope *>::const_iterator scope_iterator;
+  typedef SmallVectorImpl<DIType *>::const_iterator type_iterator;
+  typedef SmallVectorImpl<DIScope *>::const_iterator scope_iterator;
 
   iterator_range<compile_unit_iterator> compile_units() const {
     return iterator_range<compile_unit_iterator>(CUs.begin(), CUs.end());
@@ -489,11 +134,11 @@ public:
   unsigned scope_count() const { return Scopes.size(); }
 
 private:
-  SmallVector<MDCompileUnit *, 8> CUs;
-  SmallVector<MDSubprogram *, 8> SPs;
-  SmallVector<MDGlobalVariable *, 8> GVs;
-  SmallVector<MDType *, 8> TYs;
-  SmallVector<MDScope *, 8> Scopes;
+  SmallVector<DICompileUnit *, 8> CUs;
+  SmallVector<DISubprogram *, 8> SPs;
+  SmallVector<DIGlobalVariable *, 8> GVs;
+  SmallVector<DIType *, 8> TYs;
+  SmallVector<DIScope *, 8> Scopes;
   SmallPtrSet<const MDNode *, 64> NodesSeen;
   DITypeIdentifierMap TypeIdentifierMap;
 
@@ -501,7 +146,7 @@ private:
   bool TypeMapInitialized;
 };
 
-DenseMap<const Function *, MDSubprogram *> makeSubprogramMap(const Module &M);
+DenseMap<const Function *, DISubprogram *> makeSubprogramMap(const Module &M);
 
 } // end namespace llvm