X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FCodeGen%2FMachineDebugInfo.h;h=ba135def3f03012b743527c2b0f98a45b9f6a623;hb=f8a01a966120a041fe96300271573a8bf5a3e668;hp=c51b3ea84d783952d96f7659a0645900fc0beacd;hpb=f4afdd9f413c472e5785355f0d69847eaf729192;p=oota-llvm.git diff --git a/include/llvm/CodeGen/MachineDebugInfo.h b/include/llvm/CodeGen/MachineDebugInfo.h index c51b3ea84d7..ba135def3f0 100644 --- a/include/llvm/CodeGen/MachineDebugInfo.h +++ b/include/llvm/CodeGen/MachineDebugInfo.h @@ -31,6 +31,7 @@ #define LLVM_CODEGEN_MACHINEDEBUGINFO_H #include "llvm/Support/Dwarf.h" +#include "llvm/Support/DataTypes.h" #include "llvm/ADT/UniqueVector.h" #include "llvm/GlobalValue.h" #include "llvm/Pass.h" @@ -46,6 +47,8 @@ namespace llvm { class Constant; class DebugInfoDesc; class GlobalVariable; +class MachineFunction; +class MachineMove; class Module; class PointerType; class StructType; @@ -54,15 +57,7 @@ class StructType; // Debug info constants. enum { - LLVMDebugVersion = 1, // Current version of debug information. - DIInvalid = ~0U, // Invalid result indicator. - - // DebugInfoDesc type identifying tags. - DI_TAG_anchor = 0, - DI_TAG_compile_unit, - DI_TAG_global_variable, - DI_TAG_subprogram, - DI_TAG_basictype + LLVMDebugVersion = 4 // Current version of debug information. }; //===----------------------------------------------------------------------===// @@ -81,11 +76,13 @@ public: /// appropriate action for the type of field. virtual void Apply(int &Field) = 0; virtual void Apply(unsigned &Field) = 0; + virtual void Apply(int64_t &Field) = 0; virtual void Apply(uint64_t &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; + virtual void Apply(std::vector &Field) = 0; }; //===----------------------------------------------------------------------===// @@ -93,23 +90,35 @@ public: /// class DebugInfoDesc { private: + enum { + tag_mask = 0x0000ffff, + version_shift = 16 + }; + + unsigned Tag; // Content indicator. Dwarf values are // used but that does not limit use to // Dwarf writers. protected: - DebugInfoDesc(unsigned T) : Tag(T) {} + DebugInfoDesc(unsigned T) : Tag(T | (LLVMDebugVersion << version_shift)) {} public: virtual ~DebugInfoDesc() {} // Accessors - unsigned getTag() const { return Tag; } + unsigned getTag() const { return Tag & tag_mask; } + unsigned getVersion() const { return Tag >> version_shift; } - /// TagFromGlobal - Returns the Tag number from a debug info descriptor - /// GlobalVariable. Return DIIValid if operand is not an unsigned int. + /// TagFromGlobal - Returns the tag number from a debug info descriptor + /// GlobalVariable. Return DIIValid if operand is not an unsigned int. static unsigned TagFromGlobal(GlobalVariable *GV); + /// VersionFromGlobal - Returns the version number from a debug info + /// descriptor GlobalVariable. Return DIIValid if operand is not an unsigned + /// int. + static unsigned VersionFromGlobal(GlobalVariable *GV); + /// DescFactory - Create an instance of debug info descriptor based on Tag. /// Return NULL if not a recognized Tag. static DebugInfoDesc *DescFactory(unsigned Tag); @@ -122,7 +131,7 @@ public: // Subclasses should supply the following static methods. // Implement isa/cast/dyncast. - static bool classof(const DebugInfoDesc *) { return true; } + static bool classof(const DebugInfoDesc *) { return true; } //===--------------------------------------------------------------------===// // Subclasses should supply the following virtual methods. @@ -144,32 +153,25 @@ public: #endif }; - //===----------------------------------------------------------------------===// /// AnchorDesc - Descriptors of this class act as markers for identifying /// descriptors of certain groups. +class AnchoredDesc; class AnchorDesc : public DebugInfoDesc { -private: - std::string Name; // Anchor type string. +private: + unsigned AnchorTag; // Tag number of descriptors anchored + // by this object. public: - AnchorDesc() - : DebugInfoDesc(DI_TAG_anchor) - , Name("") - {} - AnchorDesc(const std::string &N) - : DebugInfoDesc(DI_TAG_anchor) - , Name(N) - {} + AnchorDesc(); + AnchorDesc(AnchoredDesc *D); // Accessors - const std::string &getName() const { return Name; } + unsigned getAnchorTag() const { return AnchorTag; } // Implement isa/cast/dyncast. static bool classof(const AnchorDesc *) { return true; } - static bool classof(const DebugInfoDesc *D) { - return D->getTag() == DI_TAG_anchor; - } + static bool classof(const DebugInfoDesc *D); /// getLinkage - get linkage appropriate for this type of descriptor. /// @@ -212,6 +214,10 @@ public: //===--------------------------------------------------------------------===// // Subclasses should supply the following virtual methods. + /// getAnchorString - Return a string used to label descriptor's anchor. + /// + virtual const char *getAnchorString() const = 0; + /// ApplyToFields - Target the visitor to the fields of the AnchoredDesc. /// virtual void ApplyToFields(DIVisitor *Visitor); @@ -222,7 +228,6 @@ public: /// source/header file. class CompileUnitDesc : public AnchoredDesc { 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. @@ -231,8 +236,8 @@ private: public: CompileUnitDesc(); + // 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; } @@ -246,13 +251,7 @@ public: // Implement isa/cast/dyncast. static bool classof(const CompileUnitDesc *) { return true; } - static bool classof(const DebugInfoDesc *D) { - return D->getTag() == DI_TAG_compile_unit; - } - - /// DebugVersionFromGlobal - Returns the version number from a compile unit - /// GlobalVariable. Return DIIValid if operand is not an unsigned int. - static unsigned DebugVersionFromGlobal(GlobalVariable *GV); + static bool classof(const DebugInfoDesc *D); /// ApplyToFields - Target the visitor to the fields of the CompileUnitDesc. /// @@ -268,6 +267,7 @@ public: /// getAnchorString - Return a string used to label this descriptor's anchor. /// + static const char *AnchorString; virtual const char *getAnchorString() const; #ifndef NDEBUG @@ -281,22 +281,33 @@ public: class TypeDesc : public DebugInfoDesc { private: DebugInfoDesc *Context; // Context debug descriptor. - std::string Name; // Type name. - uint64_t Size; // Type size. + std::string Name; // Type name (may be empty.) + CompileUnitDesc *File; // Defined compile unit (may be NULL.) + unsigned Line; // Defined line# (may be zero.) + uint64_t Size; // Type bit size (may be zero.) + uint64_t Align; // Type bit alignment (may be zero.) + uint64_t Offset; // Type bit offset (may be zero.) -protected: +public: TypeDesc(unsigned T); -public: // Accessors DebugInfoDesc *getContext() const { return Context; } const std::string &getName() const { return Name; } + CompileUnitDesc *getFile() const { return File; } + unsigned getLine() const { return Line; } uint64_t getSize() const { return Size; } + uint64_t getAlign() const { return Align; } + uint64_t getOffset() const { return Offset; } void setContext(DebugInfoDesc *C) { Context = C; } void setName(const std::string &N) { Name = N; } + void setFile(CompileUnitDesc *U) { File = U; } + void setLine(unsigned L) { Line = L; } void setSize(uint64_t S) { Size = S; } + void setAlign(uint64_t A) { Align = A; } + void setOffset(uint64_t O) { Offset = O; } - /// ApplyToFields - Target the visitor to the fields of the TypeDesc. + /// ApplyToFields - Target the visitor to the fields of the TypeDesc. /// virtual void ApplyToFields(DIVisitor *Visitor); @@ -328,15 +339,218 @@ public: void setEncoding(unsigned E) { Encoding = E; } // Implement isa/cast/dyncast. - static bool classof(const BasicTypeDesc *) { return true; } - static bool classof(const DebugInfoDesc *D) { - return D->getTag() == DI_TAG_basictype; - } + static bool classof(const BasicTypeDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the BasicTypeDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + + +//===----------------------------------------------------------------------===// +/// DerivedTypeDesc - This class packages debug information associated with a +/// derived types (eg., typedef, pointer, reference.) +class DerivedTypeDesc : public TypeDesc { +private: + TypeDesc *FromType; // Type derived from. + +public: + DerivedTypeDesc(unsigned T); + + // Accessors + TypeDesc *getFromType() const { return FromType; } + void setFromType(TypeDesc *F) { FromType = F; } + + // Implement isa/cast/dyncast. + static bool classof(const DerivedTypeDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); - /// ApplyToFields - Target the visitor to the fields of the BasicTypeDesc. + /// ApplyToFields - Target the visitor to the fields of the DerivedTypeDesc. /// virtual void ApplyToFields(DIVisitor *Visitor); + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + +//===----------------------------------------------------------------------===// +/// CompositeTypeDesc - This class packages debug information associated with a +/// array/struct types (eg., arrays, struct, union, enums.) +class CompositeTypeDesc : public DerivedTypeDesc { +private: + bool IsVector; // packed/vector array + std::vector Elements;// Information used to compose type. + +public: + CompositeTypeDesc(unsigned T); + + // Accessors + bool isVector() const { return IsVector; } + std::vector &getElements() { return Elements; } + void setIsVector() { IsVector = true; } + + // Implement isa/cast/dyncast. + static bool classof(const CompositeTypeDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the CompositeTypeDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + +//===----------------------------------------------------------------------===// +/// SubrangeDesc - This class packages debug information associated with integer +/// value ranges. +class SubrangeDesc : public DebugInfoDesc { +private: + int64_t Lo; // Low value of range. + int64_t Hi; // High value of range. + +public: + SubrangeDesc(); + + // Accessors + int64_t getLo() const { return Lo; } + int64_t getHi() const { return Hi; } + void setLo(int64_t L) { Lo = L; } + void setHi(int64_t H) { Hi = H; } + + // Implement isa/cast/dyncast. + static bool classof(const SubrangeDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the SubrangeDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + +//===----------------------------------------------------------------------===// +/// EnumeratorDesc - This class packages debug information associated with +/// named integer constants. +class EnumeratorDesc : public DebugInfoDesc { +private: + std::string Name; // Enumerator name. + int64_t Value; // Enumerator value. + +public: + EnumeratorDesc(); + + // Accessors + const std::string &getName() const { return Name; } + int64_t getValue() const { return Value; } + void setName(const std::string &N) { Name = N; } + void setValue(int64_t V) { Value = V; } + + // Implement isa/cast/dyncast. + static bool classof(const EnumeratorDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the EnumeratorDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + +//===----------------------------------------------------------------------===// +/// VariableDesc - This class packages debug information associated with a +/// subprogram variable. +/// +class VariableDesc : public DebugInfoDesc { +private: + DebugInfoDesc *Context; // Context debug descriptor. + std::string Name; // Type name (may be empty.) + CompileUnitDesc *File; // Defined compile unit (may be NULL.) + unsigned Line; // Defined line# (may be zero.) + TypeDesc *TyDesc; // Type of variable. + +public: + VariableDesc(unsigned T); + + // Accessors + DebugInfoDesc *getContext() const { return Context; } + const std::string &getName() const { return Name; } + CompileUnitDesc *getFile() const { return File; } + unsigned getLine() const { return Line; } + TypeDesc *getType() const { return TyDesc; } + void setContext(DebugInfoDesc *C) { Context = C; } + void setName(const std::string &N) { Name = N; } + void setFile(CompileUnitDesc *U) { File = U; } + void setLine(unsigned L) { Line = L; } + void setType(TypeDesc *T) { TyDesc = T; } + + // Implement isa/cast/dyncast. + static bool classof(const VariableDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the VariableDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + #ifndef NDEBUG virtual void dump(); #endif @@ -349,6 +563,8 @@ class GlobalDesc : public AnchoredDesc { private: DebugInfoDesc *Context; // Context debug descriptor. std::string Name; // Global name. + CompileUnitDesc *File; // Defined compile unit (may be NULL.) + unsigned Line; // Defined line# (may be zero.) TypeDesc *TyDesc; // Type debug descriptor. bool IsStatic; // Is the global a static. bool IsDefinition; // Is the global defined in context. @@ -360,12 +576,16 @@ public: // Accessors DebugInfoDesc *getContext() const { return Context; } const std::string &getName() const { return Name; } - TypeDesc *getTypeDesc() const { return TyDesc; } + CompileUnitDesc *getFile() const { return File; } + unsigned getLine() const { return Line; } + TypeDesc *getType() const { return TyDesc; } bool isStatic() const { return IsStatic; } bool isDefinition() const { return IsDefinition; } void setContext(DebugInfoDesc *C) { Context = C; } void setName(const std::string &N) { Name = N; } - void setTypeDesc(TypeDesc *T) { TyDesc = T; } + void setFile(CompileUnitDesc *U) { File = U; } + void setLine(unsigned L) { Line = L; } + void setType(TypeDesc *T) { TyDesc = T; } void setIsStatic(bool IS) { IsStatic = IS; } void setIsDefinition(bool ID) { IsDefinition = ID; } @@ -380,22 +600,17 @@ public: class GlobalVariableDesc : public GlobalDesc { private: GlobalVariable *Global; // llvm global. - unsigned Line; // Source line number. public: GlobalVariableDesc(); // Accessors. GlobalVariable *getGlobalVariable() const { return Global; } - unsigned getLine() const { return Line; } void setGlobalVariable(GlobalVariable *GV) { Global = GV; } - void setLine(unsigned L) { Line = L; } // Implement isa/cast/dyncast. - static bool classof(const GlobalVariableDesc *) { return true; } - static bool classof(const DebugInfoDesc *D) { - return D->getTag() == DI_TAG_global_variable; - } + static bool classof(const GlobalVariableDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); /// ApplyToFields - Target the visitor to the fields of the /// GlobalVariableDesc. @@ -411,6 +626,7 @@ public: /// getAnchorString - Return a string used to label this descriptor's anchor. /// + static const char *AnchorString; virtual const char *getAnchorString() const; #ifndef NDEBUG @@ -423,21 +639,17 @@ public: /// subprogram/function. class SubprogramDesc : public GlobalDesc { private: - // FIXME - Other attributes public: SubprogramDesc(); // Accessors - // 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; - } + static bool classof(const SubprogramDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); - /// ApplyToFields - Target the visitor to the fields of the SubprogramDesc. + /// ApplyToFields - Target the visitor to the fields of the SubprogramDesc. /// virtual void ApplyToFields(DIVisitor *Visitor); @@ -451,6 +663,7 @@ public: /// getAnchorString - Return a string used to label this descriptor's anchor. /// + static const char *AnchorString; virtual const char *getAnchorString() const; #ifndef NDEBUG @@ -458,22 +671,53 @@ public: #endif }; +//===----------------------------------------------------------------------===// +/// BlockDesc - This descriptor groups variables and blocks nested in a block. +/// +class BlockDesc : public DebugInfoDesc { +private: + DebugInfoDesc *Context; // Context debug descriptor. + +public: + BlockDesc(); + + // Accessors + DebugInfoDesc *getContext() const { return Context; } + void setContext(DebugInfoDesc *C) { Context = C; } + + // Implement isa/cast/dyncast. + static bool classof(const BlockDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the BlockDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + //===----------------------------------------------------------------------===// /// DIDeserializer - This class is responsible for casting GlobalVariables /// into DebugInfoDesc objects. class DIDeserializer { private: - unsigned DebugVersion; // Version of debug information in use. std::map GlobalDescs; // Previously defined gloabls. public: - DIDeserializer() : DebugVersion(LLVMDebugVersion) {} + DIDeserializer() {} ~DIDeserializer() {} - // Accessors - unsigned getDebugVersion() const { return DebugVersion; } - /// Deserialize - Reconstitute a GlobalVariable into it's component /// DebugInfoDesc objects. DebugInfoDesc *Deserialize(Value *V); @@ -536,16 +780,19 @@ public: /// GlobalVariables are valid as DebugInfoDesc objects. class DIVerifier { private: - unsigned DebugVersion; // Version of debug information in use. - std::set Visited; // Tracks visits during recursion. + enum { + Unknown = 0, + Invalid, + Valid + }; + std::map Validity;// Tracks prior results. std::map Counts; // Count of fields per Tag type. - - /// markVisited - Return true if the GlobalVariable hase been "seen" before. - /// Mark markVisited otherwise. - bool markVisited(GlobalVariable *GV); public: - DIVerifier() : DebugVersion(LLVMDebugVersion) {} + DIVerifier() + : Validity() + , Counts() + {} ~DIVerifier() {} /// Verify - Return true if the GlobalVariable appears to be a valid @@ -562,15 +809,17 @@ private: unsigned Line; // Source line number. unsigned Column; // Source column. unsigned SourceID; // Source ID number. + unsigned LabelID; // Label in code ID number. public: - SourceLineInfo(unsigned L, unsigned C, unsigned S) - : Line(L), Column(C), SourceID(S) {} + SourceLineInfo(unsigned L, unsigned C, unsigned S, unsigned I) + : Line(L), Column(C), SourceID(S), LabelID(I) {} // Accessors unsigned getLine() const { return Line; } unsigned getColumn() const { return Column; } unsigned getSourceID() const { return SourceID; } + unsigned getLabelID() const { return LabelID; } }; //===----------------------------------------------------------------------===// @@ -602,6 +851,68 @@ public: } }; +//===----------------------------------------------------------------------===// +/// DebugVariable - This class is used to track local variable information. +/// +class DebugVariable { +private: + VariableDesc *Desc; // Variable Descriptor. + unsigned FrameIndex; // Variable frame index. + +public: + DebugVariable(VariableDesc *D, unsigned I) + : Desc(D) + , FrameIndex(I) + {} + + // Accessors. + VariableDesc *getDesc() const { return Desc; } + unsigned getFrameIndex() const { return FrameIndex; } +}; + +//===----------------------------------------------------------------------===// +/// DebugScope - This class is used to track scope information. +/// +class DebugScope { +private: + DebugScope *Parent; // Parent to this scope. + DebugInfoDesc *Desc; // Debug info descriptor for scope. + // Either subprogram or block. + unsigned StartLabelID; // Label ID of the beginning of scope. + unsigned EndLabelID; // Label ID of the end of scope. + std::vector Scopes; // Scopes defined in scope. + std::vector Variables;// Variables declared in scope. + +public: + DebugScope(DebugScope *P, DebugInfoDesc *D) + : Parent(P) + , Desc(D) + , StartLabelID(0) + , EndLabelID(0) + , Scopes() + , Variables() + {} + ~DebugScope(); + + // Accessors. + DebugScope *getParent() const { return Parent; } + DebugInfoDesc *getDesc() const { return Desc; } + unsigned getStartLabelID() const { return StartLabelID; } + unsigned getEndLabelID() const { return EndLabelID; } + std::vector &getScopes() { return Scopes; } + std::vector &getVariables() { return Variables; } + void setStartLabelID(unsigned S) { StartLabelID = S; } + void setEndLabelID(unsigned E) { EndLabelID = E; } + + /// AddScope - Add a scope to the scope. + /// + void AddScope(DebugScope *S) { Scopes.push_back(S); } + + /// AddVariable - Add a variable to the scope. + /// + void AddVariable(DebugVariable *V) { Variables.push_back(V); } +}; + //===----------------------------------------------------------------------===// /// MachineDebugInfo - This class contains debug information specific to a /// module. Queries can be made by different debugging schemes and reformated @@ -609,8 +920,9 @@ public: /// class MachineDebugInfo : public ImmutablePass { private: - // Use the same serializer/deserializer/verifier for the module. + // Use the same deserializer/verifier for the module. DIDeserializer DR; + DIVerifier VR; // CompileUnits - Uniquing vector for compile units. UniqueVector CompileUnits; @@ -623,6 +935,20 @@ private: // Lines - List of of source line correspondence. std::vector Lines; + + // LabelID - Current number assigned to unique label numbers. + unsigned LabelID; + + // ScopeMap - Tracks the scopes in the current function. + std::map ScopeMap; + + // RootScope - Top level scope for the current function. + // + DebugScope *RootScope; + + // FrameMoves - List of moves done by a function's prolog. Used to construct + // frame maps by debug consumers. + std::vector FrameMoves; public: MachineDebugInfo(); @@ -636,6 +962,14 @@ public: /// bool doFinalization(); + /// BeginFunction - Begin gathering function debug information. + /// + void BeginFunction(MachineFunction *MF); + + /// EndFunction - Discard function debug information. + /// + void EndFunction(); + /// getDescFor - Convert a Value to a debug information descriptor. /// // FIXME - use new Value type when available. @@ -653,25 +987,20 @@ public: /// bool hasInfo() const { return !CompileUnits.empty(); } + /// NextLabelID - Return the next unique label id. + /// + unsigned NextLabelID() { return ++LabelID; } + /// RecordLabel - Records location information and associates it with a /// debug label. Returns a unique label ID used to generate a label and /// provide correspondence to the source line list. - unsigned RecordLabel(unsigned Line, unsigned Column, unsigned Source) { - Lines.push_back(new SourceLineInfo(Line, Column, Source)); - return Lines.size(); - } + unsigned RecordLabel(unsigned Line, unsigned Column, unsigned Source); /// RecordSource - Register a source file with debug info. Returns an source /// ID. unsigned RecordSource(const std::string &Directory, - const std::string &Source) { - unsigned DirectoryID = Directories.insert(Directory); - return SourceFiles.insert(SourceFileInfo(DirectoryID, Source)); - } - unsigned RecordSource(const CompileUnitDesc *CompileUnit) { - return RecordSource(CompileUnit->getDirectory(), - CompileUnit->getFileName()); - } + const std::string &Source); + unsigned RecordSource(const CompileUnitDesc *CompileUnit); /// getDirectories - Return the UniqueVector of std::string representing /// directories. @@ -712,11 +1041,41 @@ public: getGlobalVariablesUsing(M, Desc.getAnchorString()); std::vector AnchoredDescs; for (unsigned i = 0, N = Globals.size(); i < N; ++i) { - AnchoredDescs.push_back(static_cast(DR.Deserialize(Globals[i]))); + GlobalVariable *GV = Globals[i]; + + // FIXME - In the short term, changes are too drastic to continue. + if (DebugInfoDesc::TagFromGlobal(GV) == Desc.getTag() && + DebugInfoDesc::VersionFromGlobal(GV) == LLVMDebugVersion) { + AnchoredDescs.push_back(cast(DR.Deserialize(GV))); + } } return AnchoredDescs; } + + /// RecordRegionStart - Indicate the start of a region. + /// + unsigned RecordRegionStart(Value *V); + + /// RecordRegionEnd - Indicate the end of a region. + /// + unsigned RecordRegionEnd(Value *V); + + /// RecordVariable - Indicate the declaration of a local variable. + /// + void RecordVariable(Value *V, unsigned FrameIndex); + + /// getRootScope - Return current functions root scope. + /// + DebugScope *getRootScope() { return RootScope; } + + /// getOrCreateScope - Returns the scope associated with the given descriptor. + /// + DebugScope *getOrCreateScope(DebugInfoDesc *ScopeDesc); + + /// getFrameMoves - Returns a reference to a list of moves done in the current + /// function's prologue. Used to construct frame maps for debug comsumers. + std::vector &getFrameMoves() { return FrameMoves; } }; // End class MachineDebugInfo