| /* LLVM LOCAL begin (ENTIRE FILE!) */ |
| /* Internal interfaces between the LLVM backend components |
| Copyright (C) 2006 Free Software Foundation, Inc. |
| Contributed by Jim Laskey (jlaskey@apple.com) |
| |
| This file is part of GCC. |
| |
| GCC is free software; you can redistribute it and/or modify it under |
| the terms of the GNU General Public License as published by the Free |
| Software Foundation; either version 2, or (at your option) any later |
| version. |
| |
| GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GCC; see the file COPYING. If not, write to the Free |
| Software Foundation, 59 Temple Place - Suite 330, Boston, MA |
| 02111-1307, USA. */ |
| |
| //===----------------------------------------------------------------------===// |
| // This is a C++ header file that defines the debug interfaces shared among |
| // the llvm-*.cpp files. |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_DEBUG_H |
| #define LLVM_DEBUG_H |
| |
| #include "llvm-internal.h" |
| #include "llvm/Analysis/DebugInfo.h" |
| #include "llvm/Support/Dwarf.h" |
| #include "llvm/Support/ValueHandle.h" |
| #include "llvm/Support/Allocator.h" |
| |
| extern "C" { |
| #include "llvm.h" |
| } |
| |
| #include <string> |
| #include <map> |
| #include <vector> |
| |
| namespace llvm { |
| |
| // Forward declarations |
| class AllocaInst; |
| class BasicBlock; |
| class CallInst; |
| class Function; |
| class Module; |
| |
| /// DIFactory - This object assists with the construction of the various |
| /// descriptors. |
| class DIFactory { |
| Module &M; |
| LLVMContext& VMContext; |
| |
| Function *DeclareFn; // llvm.dbg.declare |
| Function *ValueFn; // llvm.dbg.value |
| |
| DIFactory(const DIFactory &); // DO NOT IMPLEMENT |
| void operator=(const DIFactory&); // DO NOT IMPLEMENT |
| public: |
| enum ComplexAddrKind { OpPlus=1, OpDeref }; |
| |
| explicit DIFactory(Module &m); |
| |
| /// GetOrCreateArray - Create an descriptor for an array of descriptors. |
| /// This implicitly uniques the arrays created. |
| DIArray GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys); |
| |
| /// GetOrCreateSubrange - Create a descriptor for a value range. This |
| /// implicitly uniques the values returned. |
| DISubrange GetOrCreateSubrange(int64_t Lo, int64_t Hi); |
| |
| /// CreateUnspecifiedParameter - Create unspeicified type descriptor |
| /// for a subroutine type. |
| DIDescriptor CreateUnspecifiedParameter(); |
| |
| /// CreateCompileUnit - Create a new descriptor for the specified compile |
| /// unit. |
| DICompileUnit CreateCompileUnit(unsigned LangID, |
| StringRef Filename, |
| StringRef Directory, |
| StringRef Producer, |
| bool isMain = false, |
| bool isOptimized = false, |
| StringRef Flags = "", |
| unsigned RunTimeVer = 0); |
| |
| /// CreateFile - Create a new descriptor for the specified file. |
| DIFile CreateFile(StringRef Filename, StringRef Directory, |
| DICompileUnit CU); |
| |
| /// CreateEnumerator - Create a single enumerator value. |
| DIEnumerator CreateEnumerator(StringRef Name, uint64_t Val); |
| |
| /// CreateBasicType - Create a basic type like int, float, etc. |
| DIBasicType CreateBasicType(DIDescriptor Context, StringRef Name, |
| DIFile F, unsigned LineNumber, |
| uint64_t SizeInBits, uint64_t AlignInBits, |
| uint64_t OffsetInBits, unsigned Flags, |
| unsigned Encoding); |
| |
| /// CreateBasicType - Create a basic type like int, float, etc. |
| DIBasicType CreateBasicTypeEx(DIDescriptor Context, StringRef Name, |
| DIFile F, unsigned LineNumber, |
| Constant *SizeInBits, Constant *AlignInBits, |
| Constant *OffsetInBits, unsigned Flags, |
| unsigned Encoding); |
| |
| /// CreateDerivedType - Create a derived type like const qualified type, |
| /// pointer, typedef, etc. |
| DIDerivedType CreateDerivedType(unsigned Tag, DIDescriptor Context, |
| StringRef Name, |
| DIFile F, |
| unsigned LineNumber, |
| uint64_t SizeInBits, uint64_t AlignInBits, |
| uint64_t OffsetInBits, unsigned Flags, |
| DIType DerivedFrom); |
| |
| /// CreateDerivedType - Create a derived type like const qualified type, |
| /// pointer, typedef, etc. |
| DIDerivedType CreateDerivedTypeEx(unsigned Tag, DIDescriptor Context, |
| StringRef Name, |
| DIFile F, |
| unsigned LineNumber, |
| Constant *SizeInBits, |
| Constant *AlignInBits, |
| Constant *OffsetInBits, unsigned Flags, |
| DIType DerivedFrom); |
| |
| /// CreateCompositeType - Create a composite type like array, struct, etc. |
| DICompositeType CreateCompositeType(unsigned Tag, DIDescriptor Context, |
| StringRef Name, |
| DIFile F, |
| unsigned LineNumber, |
| uint64_t SizeInBits, |
| uint64_t AlignInBits, |
| uint64_t OffsetInBits, unsigned Flags, |
| DIType DerivedFrom, |
| DIArray Elements, |
| unsigned RunTimeLang = 0, |
| MDNode *ContainingType = 0); |
| |
| /// CreateTemporaryType - Create a temporary forward-declared type. |
| DIType CreateTemporaryType(); |
| DIType CreateTemporaryType(DIFile F); |
| |
| /// CreateArtificialType - Create a new DIType with "artificial" flag set. |
| DIType CreateArtificialType(DIType Ty); |
| |
| /// CreateCompositeType - Create a composite type like array, struct, etc. |
| DICompositeType CreateCompositeTypeEx(unsigned Tag, DIDescriptor Context, |
| StringRef Name, |
| DIFile F, |
| unsigned LineNumber, |
| Constant *SizeInBits, |
| Constant *AlignInBits, |
| Constant *OffsetInBits, |
| unsigned Flags, |
| DIType DerivedFrom, |
| DIArray Elements, |
| unsigned RunTimeLang = 0, |
| MDNode *ContainingType = 0); |
| |
| /// CreateSubprogram - Create a new descriptor for the specified subprogram. |
| /// See comments in DISubprogram for descriptions of these fields. |
| DISubprogram CreateSubprogram(DIDescriptor Context, StringRef Name, |
| StringRef DisplayName, |
| StringRef LinkageName, |
| DIFile F, unsigned LineNo, |
| DIType Ty, bool isLocalToUnit, |
| bool isDefinition, |
| unsigned VK = 0, |
| unsigned VIndex = 0, |
| DIType ContainingType = DIType(), |
| unsigned Flags = 0, |
| bool isOptimized = false, |
| Function *Fn = 0); |
| |
| /// CreateSubprogramDefinition - Create new subprogram descriptor for the |
| /// given declaration. |
| DISubprogram CreateSubprogramDefinition(DISubprogram &SPDeclaration); |
| |
| /// CreateGlobalVariable - Create a new descriptor for the specified global. |
| DIGlobalVariable |
| CreateGlobalVariable(DIDescriptor Context, StringRef Name, |
| StringRef DisplayName, |
| StringRef LinkageName, |
| DIFile F, |
| unsigned LineNo, DIType Ty, bool isLocalToUnit, |
| bool isDefinition, llvm::GlobalVariable *GV); |
| |
| /// CreateGlobalVariable - Create a new descriptor for the specified constant. |
| DIGlobalVariable |
| CreateGlobalVariable(DIDescriptor Context, StringRef Name, |
| StringRef DisplayName, |
| StringRef LinkageName, |
| DIFile F, |
| unsigned LineNo, DIType Ty, bool isLocalToUnit, |
| bool isDefinition, llvm::Constant *C); |
| |
| /// CreateVariable - Create a new descriptor for the specified variable. |
| DIVariable CreateVariable(unsigned Tag, DIDescriptor Context, |
| StringRef Name, |
| DIFile F, unsigned LineNo, |
| DIType Ty, bool AlwaysPreserve = false, |
| unsigned Flags = 0); |
| |
| /// CreateComplexVariable - Create a new descriptor for the specified |
| /// variable which has a complex address expression for its address. |
| DIVariable CreateComplexVariable(unsigned Tag, DIDescriptor Context, |
| StringRef Name, DIFile F, unsigned LineNo, |
| DIType Ty, Value *const *Addr, |
| unsigned NumAddr); |
| |
| /// CreateLexicalBlock - This creates a descriptor for a lexical block |
| /// with the specified parent context. |
| DILexicalBlock CreateLexicalBlock(DIDescriptor Context, DIFile F, |
| unsigned Line = 0, unsigned Col = 0); |
| |
| /// CreateNameSpace - This creates new descriptor for a namespace |
| /// with the specified parent context. |
| DINameSpace CreateNameSpace(DIDescriptor Context, StringRef Name, |
| DIFile F, unsigned LineNo); |
| |
| /// CreateLocation - Creates a debug info location. |
| DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo, |
| DIScope S, DILocation OrigLoc); |
| |
| /// CreateLocation - Creates a debug info location. |
| DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo, |
| DIScope S, MDNode *OrigLoc = 0); |
| |
| /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call. |
| Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D, |
| BasicBlock *InsertAtEnd); |
| |
| /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call. |
| Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D, |
| Instruction *InsertBefore); |
| |
| /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call. |
| Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset, |
| DIVariable D, BasicBlock *InsertAtEnd); |
| |
| /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call. |
| Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset, |
| DIVariable D, Instruction *InsertBefore); |
| |
| // RecordType - Record DIType in a module such that it is not lost even if |
| // it is not referenced through debug info anchors. |
| void RecordType(DIType T); |
| |
| private: |
| Constant *GetTagConstant(unsigned TAG); |
| }; |
| |
| /// DebugInfo - This class gathers all debug information during compilation and |
| /// is responsible for emitting to llvm globals or pass directly to the backend. |
| class DebugInfo { |
| private: |
| Module *M; // The current module. |
| DIFactory DebugFactory; |
| const char *CurFullPath; // Previous location file encountered. |
| int CurLineNo; // Previous location line# encountered. |
| const char *PrevFullPath; // Previous location file encountered. |
| int PrevLineNo; // Previous location line# encountered. |
| BasicBlock *PrevBB; // Last basic block encountered. |
| DICompileUnit TheCU; // The compile unit. |
| |
| // Current GCC lexical block (or enclosing FUNCTION_DECL). |
| tree_node *CurrentGCCLexicalBlock; |
| |
| std::map<tree_node *, WeakVH > TypeCache; |
| // Cache of previously constructed |
| // Types. |
| std::map<tree_node *, WeakVH > SPCache; |
| // Cache of previously constructed |
| // Subprograms. |
| std::map<tree_node *, WeakVH> NameSpaceCache; |
| // Cache of previously constructed name |
| // spaces. |
| |
| SmallVector<WeakVH, 4> RegionStack; |
| // Stack to track declarative scopes. |
| |
| std::map<tree_node *, WeakVH> RegionMap; |
| |
| // Starting at the 'desired' BLOCK, recursively walk back to the |
| // 'grand' context, and return pushing regions to make 'desired' the |
| // current context. 'desired' should be a GCC lexical BLOCK. |
| // 'grand' may be a BLOCK or a FUNCTION_DECL, and it's presumed to |
| // be an ancestor of 'desired'. |
| void push_regions(tree_node *desired, tree_node *grand); |
| |
| /// FunctionNames - This is a storage for function names that are |
| /// constructed on demand. For example, C++ destructors, C++ operators etc.. |
| llvm::BumpPtrAllocator FunctionNames; |
| |
| public: |
| DebugInfo(Module *m); |
| |
| /// Initialize - Initialize debug info by creating compile unit for |
| /// main_input_filename. This must be invoked after language dependent |
| /// initialization is done. |
| void Initialize(); |
| |
| // Accessors. |
| void setLocationFile(const char *FullPath) { CurFullPath = FullPath; } |
| void setLocationLine(int LineNo) { CurLineNo = LineNo; } |
| |
| tree_node *getCurrentLexicalBlock() { return CurrentGCCLexicalBlock; } |
| void setCurrentLexicalBlock(tree_node *lb) { CurrentGCCLexicalBlock = lb; } |
| |
| // Pop the current region/lexical-block back to 'grand', then push |
| // regions to arrive at 'desired'. This was inspired (cribbed from) |
| // by GCC's cfglayout.c:change_scope(). |
| void change_regions(tree_node *desired, tree_node *grand); |
| |
| /// CreateSubprogramFromFnDecl - Constructs the debug code for entering a function - |
| /// "llvm.dbg.func.start." |
| DISubprogram CreateSubprogramFromFnDecl(tree_node *FnDecl); |
| |
| /// EmitFunctionStart - Constructs the debug code for entering a function - |
| /// "llvm.dbg.func.start", and pushes it onto the RegionStack. |
| void EmitFunctionStart(tree_node *FnDecl); |
| |
| /// EmitFunctionEnd - Constructs the debug code for exiting a declarative |
| /// region - "llvm.dbg.region.end." |
| void EmitFunctionEnd(BasicBlock *CurBB, bool EndFunction); |
| |
| /// EmitDeclare - Constructs the debug code for allocation of a new variable. |
| /// region - "llvm.dbg.declare." |
| void EmitDeclare(tree_node *decl, unsigned Tag, const char *Name, |
| tree_node *type, Value *AI, LLVMBuilder &Builder); |
| |
| /// EmitStopPoint - Emit a call to llvm.dbg.stoppoint to indicate a change of |
| /// source line. |
| void EmitStopPoint(Function *Fn, BasicBlock *CurBB, LLVMBuilder &Builder); |
| |
| /// EmitGlobalVariable - Emit information about a global variable. |
| /// |
| void EmitGlobalVariable(GlobalVariable *GV, tree_node *decl); |
| |
| /// getOrCreateType - Get the type from the cache or create a new type if |
| /// necessary. |
| DIType getOrCreateType(tree_node *type); |
| |
| /// createBasicType - Create BasicType. |
| DIType createBasicType(tree_node *type); |
| |
| /// createMethodType - Create MethodType. |
| DIType createMethodType(tree_node *type); |
| |
| /// createPointerType - Create PointerType. |
| DIType createPointerType(tree_node *type); |
| |
| /// createArrayType - Create ArrayType. |
| DIType createArrayType(tree_node *type); |
| |
| /// createEnumType - Create EnumType. |
| DIType createEnumType(tree_node *type); |
| |
| /// createStructType - Create StructType for struct or union or class. |
| DIType createStructType(tree_node *type); |
| |
| /// createVarinatType - Create variant type or return MainTy. |
| DIType createVariantType(tree_node *type, DIType MainTy); |
| |
| /// getOrCreateCompileUnit - Create a new compile unit. |
| DICompileUnit getOrCreateCompileUnit(const char *FullPath, |
| bool isMain = false); |
| |
| /// getOrCreateFile - Get DIFile descriptor. |
| DIFile getOrCreateFile(const char *FullPath); |
| |
| /// findRegion - Find tree_node N's region. |
| DIDescriptor findRegion(tree_node *n); |
| |
| /// getOrCreateNameSpace - Get name space descriptor for the tree node. |
| DINameSpace getOrCreateNameSpace(tree_node *Node, DIDescriptor Context); |
| |
| /// getFunctionName - Get function name for the given FnDecl. If the |
| /// name is constructred on demand (e.g. C++ destructor) then the name |
| /// is stored on the side. |
| StringRef getFunctionName(tree_node *FnDecl); |
| |
| /// getCU - Get Compile Unit. |
| DICompileUnit getCU() { return TheCU;} |
| |
| /// replaceBasicTypesFromPCH - Replace basic type debug info received |
| /// from PCH file. |
| void replaceBasicTypesFromPCH(); |
| }; |
| |
| } // end namespace llvm |
| |
| #endif /* LLVM_DEBUG_H */ |
| /* LLVM LOCAL end (ENTIRE FILE!) */ |
