X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAnalysis%2FDebugInfo.h;h=39fe01d3428b1518c9d8749943c553d718fd6717;hb=104cf9e02b0ed94d4173869a598af6c6972a8660;hp=fae9a4422535608b53c17caaf2bba6de844cb645;hpb=a22d57d6f8215717298ae0cef34d00ab5104ddea;p=oota-llvm.git diff --git a/include/llvm/Analysis/DebugInfo.h b/include/llvm/Analysis/DebugInfo.h index fae9a442253..39fe01d3428 100644 --- a/include/llvm/Analysis/DebugInfo.h +++ b/include/llvm/Analysis/DebugInfo.h @@ -8,15 +8,20 @@ //===----------------------------------------------------------------------===// // // 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 { class BasicBlock; @@ -26,102 +31,121 @@ 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 { - public: - enum { - Version7 = 7 << 16, // Current version of debug information. - Version6 = 6 << 16, // Constant for version 6. - Version5 = 5 << 16, // Constant for version 5. - Version4 = 4 << 16, // Constant for version 4. - VersionMask = 0xffff0000 // Mask for version number. - }; - 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); - - unsigned getVersion() const { - return getUnsignedField(0) & VersionMask; - } - - 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); } uint64_t getUInt64Field(unsigned Elt) const; DIDescriptor getDescriptorField(unsigned Elt) const; - + template DescTy getFieldAs(unsigned Elt) const { return DescTy(getDescriptorField(Elt).getGV()); } - + 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; + } unsigned getTag() const { - return getUnsignedField(0) & ~VersionMask; + return getUnsignedField(0) & ~LLVMDebugVersionMask; } - static inline bool classof(const DIDescriptor *D) { return true; } - }; - - /// DIAnchor - A wrapper for various anchor descriptors. - class DIAnchor : public DIDescriptor { - public: - explicit DIAnchor(GlobalVariable *GV = 0); - - unsigned getAnchorTag() const { return getUnsignedField(1); } + + /// ValidDebugInfo - Return true if V represents valid debug info value. + static bool ValidDebugInfo(Value *V, CodeGenOpt::Level OptLevel); + + /// 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); } - static bool isSubrange(unsigned); - static inline bool classof(const DISubrange *) { return true; } - static inline bool classof(const DIDescriptor *D) { - return isSubrange(D->getTag()); - } }; - + /// DIArray - This descriptor holds an array of descriptors. class DIArray : public DIDescriptor { public: explicit DIArray(GlobalVariable *GV = 0) : DIDescriptor(GV) {} - + unsigned getNumElements() const; DIDescriptor getElement(unsigned Idx) const { return getDescriptorField(Idx); } }; - + /// 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); } + 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}'). @@ -129,27 +153,58 @@ namespace llvm { /// type/precision or a file/line pair for location info. class DIEnumerator : public DIDescriptor { public: - explicit DIEnumerator(GlobalVariable *GV = 0); - - std::string getName() const { return getStringField(1); } + explicit DIEnumerator(GlobalVariable *GV = 0) + : DIDescriptor(GV, dwarf::DW_TAG_enumerator) {} + + const std::string &getName(std::string &F) const { + return getStringField(1, F); + } uint64_t getEnumValue() const { return getUInt64Field(2); } }; - + /// DIType - This is a wrapper for a type. /// FIXME: Types should be factored much better so that CV qualifiers and /// others do not require a huge and empty descriptor full of zeros. class DIType : public DIDescriptor { + public: + enum { + FlagPrivate = 1 << 0, + FlagProtected = 1 << 1, + FlagFwdDecl = 1 << 2 + }; + protected: DIType(GlobalVariable *GV, unsigned Tag) : DIDescriptor(GV, Tag) {} // This ctor is used when the Tag has already been validated by a derived // ctor. DIType(GlobalVariable *GV, bool, bool) : DIDescriptor(GV) {} + + public: + /// isDerivedType - Return true if the specified tag is legal for + /// DIDerivedType. + static bool isDerivedType(unsigned TAG); + + /// isCompositeType - Return true if the specified tag is legal for + /// DICompositeType. + static bool isCompositeType(unsigned TAG); + + /// isBasicType - Return true if the specified tag is legal for + /// DIBasicType. + static bool isBasicType(unsigned TAG) { + return TAG == dwarf::DW_TAG_base_type; + } + + /// Verify - Verify that a type descriptor is well formed. + bool Verify() const; public: explicit DIType(GlobalVariable *GV); explicit DIType() {} - + 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(3); } unsigned getLineNumber() const { return getUnsignedField(4); } uint64_t getSizeInBits() const { return getUInt64Field(5); } @@ -158,18 +213,26 @@ namespace llvm { // carry this is just plain insane. uint64_t getOffsetInBits() const { return getUInt64Field(7); } unsigned getFlags() const { return getUnsignedField(8); } + bool isPrivate() const { return (getFlags() & FlagPrivate) != 0; } + bool isProtected() const { return (getFlags() & FlagProtected) != 0; } + bool isForwardDecl() const { return (getFlags() & FlagFwdDecl) != 0; } + + /// 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, /// a typedef, a pointer or reference, etc. class DIDerivedType : public DIType { @@ -177,120 +240,182 @@ 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); } - std::string getFileName() const { return getStringField(10); } - std::string getDirectory() const { return getStringField(11); } - /// isDerivedType - Return true if the specified tag is legal for - /// DIDerivedType. - static bool isDerivedType(unsigned TAG); + /// 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; - static inline bool classof(const DIDerivedType *) { return true; } - static inline bool classof(const DIDescriptor *D) { - return isDerivedType(D->getTag()); - } + /// replaceAllUsesWith - Replace all uses of debug info referenced by + /// this descriptor. After this completes, the current debug info value + /// is erased. + void replaceAllUsesWith(DIDescriptor &D); }; - /// DICompositeType - This descriptor holds a type that can refer to multiple /// other types, like a function or struct. /// FIXME: Why is this a DIDerivedType?? class DICompositeType : public DIDerivedType { public: - explicit DICompositeType(GlobalVariable *GV); - - DIArray getTypeArray() const { return getFieldAs(10); } - std::string getFileName() const { return getStringField(11); } - std::string getDirectory() const { return getStringField(12); } - - /// isCompositeType - Return true if the specified tag is legal for - /// DICompositeType. - static bool isCompositeType(unsigned TAG); - static inline bool classof(const DIDerivedType *) { return true; } - static inline bool classof(const DIDescriptor *D) { - return isCompositeType(D->getTag()); + 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); } + + /// 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. class DIGlobal : public DIDescriptor { protected: explicit DIGlobal(GlobalVariable *GV, unsigned RequiredTag) : DIDescriptor(GV, RequiredTag) {} + + /// isSubprogram - Return true if the specified tag is legal for + /// DISubprogram. + static bool isSubprogram(unsigned TAG) { + return TAG == dwarf::DW_TAG_subprogram; + } + + /// isGlobalVariable - Return true if the specified tag is legal for + /// DIGlobalVariable. + static bool isGlobalVariable(unsigned TAG) { + return TAG == dwarf::DW_TAG_variable; + } + public: - + 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(6); } unsigned getLineNumber() const { return getUnsignedField(7); } DIType getType() const { return getFieldAs(8); } - + /// isLocalToUnit - Return true if this subprogram is local to the current /// compile unit, like 'static' in C. unsigned isLocalToUnit() const { return getUnsignedField(9); } unsigned isDefinition() const { return getUnsignedField(10); } + + /// 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(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; + + /// 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(3); } unsigned getLineNumber() const { return getUnsignedField(4); } DIType getType() const { return getFieldAs(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); } }; - + /// DIFactory - This object assists with the construction of the various /// 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 @@ -299,23 +424,11 @@ namespace llvm { Function *DeclareFn; // llvm.dbg.declare StringMap StringCache; DenseMap SimpleConstantCache; - + DIFactory(const DIFactory &); // DO NOT IMPLEMENT void operator=(const DIFactory&); // DO NOT IMPLEMENT 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. @@ -324,27 +437,28 @@ namespace llvm { /// GetOrCreateSubrange - Create a descriptor for a value range. This /// implicitly uniques the values returned. DISubrange GetOrCreateSubrange(int64_t Lo, int64_t Hi); - - + /// CreateCompileUnit - Create a new descriptor for the specified compile /// unit. DICompileUnit CreateCompileUnit(unsigned LangID, const std::string &Filename, const std::string &Directory, - const std::string &Producer); + const std::string &Producer, + bool isMain = false, + bool isOptimized = false, + const char *Flags = "", + unsigned RunTimeVer = 0); /// CreateEnumerator - Create a single enumerator value. DIEnumerator CreateEnumerator(const std::string &Name, uint64_t Val); - + /// CreateBasicType - Create a basic type like int, float, etc. DIBasicType CreateBasicType(DIDescriptor Context, const std::string &Name, 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. DIDerivedType CreateDerivedType(unsigned Tag, DIDescriptor Context, @@ -353,9 +467,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, @@ -367,9 +479,8 @@ 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. DISubprogram CreateSubprogram(DIDescriptor Context, const std::string &Name, @@ -377,9 +488,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 @@ -388,28 +497,23 @@ 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. DIBlock CreateBlock(DIDescriptor Context); - + /// InsertStopPoint - Create a new llvm.dbg.stoppoint intrinsic invocation, /// inserting it at the end of the specified basic block. void InsertStopPoint(DICompileUnit CU, unsigned LineNo, unsigned ColNo, BasicBlock *BB); - + /// InsertSubprogramStart - Create a new llvm.dbg.func.start intrinsic to /// mark the start of the specified subprogram. void InsertSubprogramStart(DISubprogram SP, BasicBlock *BB); @@ -417,23 +521,22 @@ namespace llvm { /// InsertRegionStart - Insert a new llvm.dbg.region.start intrinsic call to /// mark the start of a region for the specified scoping descriptor. void InsertRegionStart(DIDescriptor D, BasicBlock *BB); - + /// InsertRegionEnd - Insert a new llvm.dbg.region.end intrinsic call to /// mark the end of a region for the specified scoping descriptor. void InsertRegionEnd(DIDescriptor D, BasicBlock *BB); - + /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call. void InsertDeclare(llvm::Value *Storage, DIVariable D, BasicBlock *BB); - + 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); }; - + /// Finds the stoppoint coressponding to this instruction, that is the /// stoppoint that dominates this instruction const DbgStopPointInst *findStopPoint(const Instruction *Inst); @@ -445,6 +548,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 &CompileUnits, + SmallVector &GlobalVars, + SmallVector &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