X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAnalysis%2FDebugInfo.h;h=42a522500fd60dc6830e372ac8150534044e6b7b;hb=40a5a1b39ee1cd40ff9d04740386b667fb27b340;hp=6a0eb070c5b73df29ecb7dd6113f271b90709f83;hpb=77eaa6880b8209acc05de733ebaba5d146c321a0;p=oota-llvm.git diff --git a/include/llvm/Analysis/DebugInfo.h b/include/llvm/Analysis/DebugInfo.h index 6a0eb070c5b..42a522500fd 100644 --- a/include/llvm/Analysis/DebugInfo.h +++ b/include/llvm/Analysis/DebugInfo.h @@ -8,7 +8,9 @@ //===----------------------------------------------------------------------===// // // 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. // //===----------------------------------------------------------------------===// @@ -34,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 @@ -56,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; @@ -74,12 +76,15 @@ namespace llvm { /// 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); } }; @@ -87,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); } @@ -107,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 { @@ -148,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); @@ -218,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. @@ -232,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(9); } /// getOriginalTypeSize - If this type is derived from a base type then @@ -247,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(10); } unsigned getRunTimeLang() const { return getUnsignedField(11); } @@ -305,9 +325,24 @@ 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(8); } + /// getReturnTypeName - Subprogram return types are encoded either as + /// DIType or as DICompositeType. + const std::string &getReturnTypeName(std::string &F) const { + DICompositeType DCT(getFieldAs(8)); + if (!DCT.isNull()) { + DIArray A = DCT.getTypeArray(); + DIType T(A.getElement(0).getGV()); + return T.getName(F); + } + DIType T(getFieldAs(8)); + return T.getName(F); + } + /// Verify - Verify that a subprogram descriptor is well formed. bool Verify() const; @@ -322,7 +357,9 @@ namespace llvm { /// 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. @@ -336,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 { @@ -359,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); } };