X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FCodeGen%2FMachineModuleInfo.h;h=b7b90198b1681c004e78eb2c00b4693d2e1ee6f3;hb=75549f4444cbb14e73c8f10ab90ec36c60413e8e;hp=f2a2b7b674c4c6afbe032666b295d6cbf8cfc727;hpb=914c970899ce3281a8d14d924ec1bfe335624ac6;p=oota-llvm.git diff --git a/include/llvm/CodeGen/MachineModuleInfo.h b/include/llvm/CodeGen/MachineModuleInfo.h index f2a2b7b674c..b7b90198b16 100644 --- a/include/llvm/CodeGen/MachineModuleInfo.h +++ b/include/llvm/CodeGen/MachineModuleInfo.h @@ -31,257 +31,42 @@ #ifndef LLVM_CODEGEN_MACHINEMODULEINFO_H #define LLVM_CODEGEN_MACHINEMODULEINFO_H -#include "llvm/GlobalValue.h" -#include "llvm/Pass.h" -#include "llvm/ADT/DenseMap.h" -#include "llvm/ADT/SmallPtrSet.h" +#include "llvm/Support/Dwarf.h" +#include "llvm/Support/DataTypes.h" #include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/UniqueVector.h" -#include "llvm/Support/DataTypes.h" -#include "llvm/Support/Dwarf.h" +#include "llvm/ADT/SmallPtrSet.h" +#include "llvm/ADT/SmallSet.h" +#include "llvm/ADT/StringMap.h" +#include "llvm/CodeGen/MachineLocation.h" +#include "llvm/GlobalValue.h" +#include "llvm/Pass.h" namespace llvm { //===----------------------------------------------------------------------===// // Forward declarations. -class AnchoredDesc; -class CompileUnitDesc; class Constant; -class DebugInfoDesc; +class MDNode; class GlobalVariable; class MachineBasicBlock; class MachineFunction; -class MachineMove; class Module; class PointerType; class StructType; -class VariableDesc; - -//===----------------------------------------------------------------------===// -/// DIVisitor - Subclasses of this class apply steps to each of the fields in -/// the supplied DebugInfoDesc. -class DIVisitor { -public: - DIVisitor() {} - virtual ~DIVisitor() {} - - /// ApplyToFields - Target the visitor to each field of the debug information - /// descriptor. - void ApplyToFields(DebugInfoDesc *DD); - - /// Apply - Subclasses override each of these methods to perform the - /// 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; -}; - -//===----------------------------------------------------------------------===// -/// DIDeserializer - This class is responsible for casting GlobalVariables -/// into DebugInfoDesc objects. -class DIDeserializer { - // Previously defined gloabls. - DenseMap GlobalDescs; -public: - const DenseMap &getGlobalDescs() const { - return GlobalDescs; - } - - /// Deserialize - Reconstitute a GlobalVariable into it's component - /// DebugInfoDesc objects. - DebugInfoDesc *Deserialize(Value *V); - DebugInfoDesc *Deserialize(GlobalVariable *GV); -}; - -//===----------------------------------------------------------------------===// -/// DISerializer - This class is responsible for casting DebugInfoDesc objects -/// into GlobalVariables. -class DISerializer { - Module *M; // Definition space module. - PointerType *StrPtrTy; // A "i8*" type. Created lazily. - PointerType *EmptyStructPtrTy; // A "{ }*" type. Created lazily. - - // Types per Tag. Created lazily. - std::map TagTypes; - - // Previously defined descriptors. - DenseMap DescGlobals; - - // Previously defined strings. - DenseMap StringCache; -public: - DISerializer() - : M(NULL), StrPtrTy(NULL), EmptyStructPtrTy(NULL), TagTypes(), - DescGlobals(), StringCache() - {} - // Accessors - Module *getModule() const { return M; }; - void setModule(Module *module) { M = module; } - - /// getStrPtrType - Return a "i8*" type. - /// - const PointerType *getStrPtrType(); - - /// getEmptyStructPtrType - Return a "{ }*" type. - /// - const PointerType *getEmptyStructPtrType(); - - /// getTagType - Return the type describing the specified descriptor (via - /// tag.) - const StructType *getTagType(DebugInfoDesc *DD); - - /// getString - Construct the string as constant string global. - /// - Constant *getString(const std::string &String); - - /// Serialize - Recursively cast the specified descriptor into a - /// GlobalVariable so that it can be serialized to a .bc or .ll file. - GlobalVariable *Serialize(DebugInfoDesc *DD); - - /// addDescriptor - Directly connect DD with existing GV. - void addDescriptor(DebugInfoDesc *DD, GlobalVariable *GV); -}; - -//===----------------------------------------------------------------------===// -/// DIVerifier - This class is responsible for verifying the given network of -/// GlobalVariables are valid as DebugInfoDesc objects. -class DIVerifier { - enum { - Unknown = 0, - Invalid, - Valid - }; - DenseMap Validity; // Tracks prior results. - std::map Counts; // Count of fields per Tag type. -public: - DIVerifier() - : Validity(), Counts() - {} - /// Verify - Return true if the GlobalVariable appears to be a valid - /// serialization of a DebugInfoDesc. - bool Verify(Value *V); - bool Verify(GlobalVariable *GV); - - /// isVerified - Return true if the specified GV has already been - /// verified as a debug information descriptor. - bool isVerified(GlobalVariable *GV); -}; - -//===----------------------------------------------------------------------===// -/// SourceLineInfo - This class is used to record source line correspondence. -/// -class SourceLineInfo { - 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, 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; } -}; - -//===----------------------------------------------------------------------===// -/// SourceFileInfo - This class is used to track source information. -/// -class SourceFileInfo { - unsigned DirectoryID; // Directory ID number. - std::string Name; // File name (not including directory.) -public: - SourceFileInfo(unsigned D, const std::string &N) : DirectoryID(D), Name(N) {} - - // Accessors - unsigned getDirectoryID() const { return DirectoryID; } - const std::string &getName() const { return Name; } - - /// operator== - Used by UniqueVector to locate entry. - /// - bool operator==(const SourceFileInfo &SI) const { - return getDirectoryID() == SI.getDirectoryID() && getName() == SI.getName(); - } - - /// operator< - Used by UniqueVector to locate entry. - /// - bool operator<(const SourceFileInfo &SI) const { - return getDirectoryID() < SI.getDirectoryID() || - (getDirectoryID() == SI.getDirectoryID() && getName() < SI.getName()); - } -}; - -//===----------------------------------------------------------------------===// -/// DebugVariable - This class is used to track local variable information. -/// -class DebugVariable { -private: - VariableDesc *Desc; // Variable Descriptor. - unsigned FrameIndex; // Variable frame index. - +/// MachineModuleInfoImpl - This class can be derived from and used by targets +/// to hold private target-specific information for each Module. Objects of +/// type are accessed/created with MMI::getInfo and destroyed when the +/// MachineModuleInfo is destroyed. +class MachineModuleInfoImpl { public: - DebugVariable(VariableDesc *D, unsigned I) - : Desc(D) - , FrameIndex(I) - {} - - // Accessors. - VariableDesc *getDesc() const { return Desc; } - unsigned getFrameIndex() const { return FrameIndex; } + virtual ~MachineModuleInfoImpl(); }; - -//===----------------------------------------------------------------------===// -/// 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); } -}; //===----------------------------------------------------------------------===// /// LandingPadInfo - This structure is used to retain landing pad info for @@ -308,36 +93,17 @@ struct LandingPadInfo { /// schemes and reformated for specific use. /// class MachineModuleInfo : public ImmutablePass { -private: - // Use the same deserializer/verifier for the module. - DIDeserializer DR; - DIVerifier VR; + /// ObjFileMMI - This is the object-file-format-specific implementation of + /// MachineModuleInfoImpl, which lets targets accumulate whatever info they + /// want. + MachineModuleInfoImpl *ObjFileMMI; - // CompileUnits - Uniquing vector for compile units. - UniqueVector CompileUnits; - - // Directories - Uniquing vector for directories. - UniqueVector Directories; - - // SourceFiles - Uniquing vector for source files. - UniqueVector SourceFiles; - - // Lines - List of of source line correspondence. - std::vector Lines; - // LabelIDList - One entry per assigned label. Normally the entry is equal to // the list index(+1). If the entry is zero then the label has been deleted. // Any other value indicates the label has been deleted by is mapped to // another label. std::vector LabelIDList; - // 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 and exception handling consumers. std::vector FrameMoves; @@ -363,46 +129,58 @@ private: // common EH frames. std::vector Personalities; - // UsedFunctions - the functions in the llvm.used list in a more easily - // searchable format. + /// UsedFunctions - The functions in the @llvm.used list in a more easily + /// searchable format. This does not include the functions in + /// llvm.compiler.used. SmallPtrSet UsedFunctions; + /// UsedDbgLabels - labels are used by debug info entries. + SmallSet UsedDbgLabels; + bool CallsEHReturn; bool CallsUnwindInit; + + /// DbgInfoAvailable - True if debugging information is available + /// in this module. + bool DbgInfoAvailable; + public: static char ID; // Pass identification, replacement for typeid + typedef DenseMap > VariableDbgInfoMapTy; + VariableDbgInfoMapTy VariableDbgInfo; + MachineModuleInfo(); ~MachineModuleInfo(); - /// doInitialization - Initialize the state for a new module. - /// bool doInitialization(); - - /// doFinalization - Tear down the state after completion of a module. - /// bool doFinalization(); - + /// BeginFunction - Begin gathering function meta information. /// - void BeginFunction(MachineFunction *MF); + void BeginFunction(MachineFunction *) {} /// EndFunction - Discard function meta information. /// void EndFunction(); - /// getDescFor - Convert a Value to a debug information descriptor. + /// getInfo - Keep track of various per-function pieces of information for + /// backends that would like to do so. /// - // FIXME - use new Value type when available. - DebugInfoDesc *getDescFor(Value *V); + template + Ty &getObjFileInfo() { + if (ObjFileMMI == 0) + ObjFileMMI = new Ty(*this); + + assert((void*)dynamic_cast(ObjFileMMI) == (void*)ObjFileMMI && + "Invalid concrete type or multiple inheritence for getInfo"); + return *static_cast(ObjFileMMI); + } - /// Verify - Verify that a Value is debug information descriptor. - /// - bool Verify(Value *V) { return VR.Verify(V); } - - /// isVerified - Return true if the specified GV has already been - /// verified as a debug information descriptor. - bool isVerified(GlobalVariable *GV) { return VR.isVerified(GV); } + template + const Ty &getObjFileInfo() const { + return const_cast(this)->getObjFileInfo(); + } /// AnalyzeModule - Scan the module for global debug information. /// @@ -410,8 +188,9 @@ public: /// hasDebugInfo - Returns true if valid debug info is present. /// - bool hasDebugInfo() const { return !CompileUnits.empty(); } - + bool hasDebugInfo() const { return DbgInfoAvailable; } + void setDebugInfoAvailability(bool avail) { DbgInfoAvailable = true; } + bool callsEHReturn() const { return CallsEHReturn; } void setCallsEHReturn(bool b) { CallsEHReturn = b; } @@ -426,11 +205,6 @@ public: return ID; } - /// RecordSourceLine - Records location information and associates it with a - /// label. Returns a unique label ID used to generate a label and - /// provide correspondence to the source line list. - unsigned RecordSourceLine(unsigned Line, unsigned Column, unsigned Source); - /// InvalidateLabel - Inhibit use of the specified label # from /// MachineModuleInfo, for example because the code was deleted. void InvalidateLabel(unsigned LabelID) { @@ -455,68 +229,19 @@ public: return LabelID ? LabelIDList[LabelID - 1] : 0; } - /// RecordSource - Register a source file with debug info. Returns an source - /// ID. - unsigned RecordSource(const std::string &Directory, - const std::string &Source); - unsigned RecordSource(const CompileUnitDesc *CompileUnit); - - /// getDirectories - Return the UniqueVector of std::string representing - /// directories. - const UniqueVector &getDirectories() const { - return Directories; - } - - /// getSourceFiles - Return the UniqueVector of source files. - /// - const UniqueVector &getSourceFiles() const { - return SourceFiles; + /// isDbgLabelUsed - Return true if label with LabelID is used by + /// DwarfWriter. + bool isDbgLabelUsed(unsigned LabelID) { + return UsedDbgLabels.count(LabelID); } - /// getSourceLines - Return a vector of source lines. - /// - const std::vector &getSourceLines() const { - return Lines; + /// RecordUsedDbgLabel - Mark label with LabelID as used. This is used + /// by DwarfWriter to inform DebugLabelFolder that certain labels are + /// not to be deleted. + void RecordUsedDbgLabel(unsigned LabelID) { + UsedDbgLabels.insert(LabelID); } - - /// SetupCompileUnits - Set up the unique vector of compile units. - /// - void SetupCompileUnits(Module &M); - - /// getCompileUnits - Return a vector of debug compile units. - /// - const UniqueVector getCompileUnits() const; - - /// getGlobalVariablesUsing - Return all of the GlobalVariables that use the - /// named GlobalVariable. - void getGlobalVariablesUsing(Module &M, const std::string &RootName, - std::vector &Result); - /// getAnchoredDescriptors - Return a vector of anchored debug descriptors. - /// - void getAnchoredDescriptors(Module &M, const AnchoredDesc *Desc, - std::vector &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(GlobalValue *GV, 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 and exception /// handling comsumers. @@ -550,9 +275,11 @@ public: return Personalities; } - // UsedFunctions - Return set of the functions in the llvm.used list. - const SmallPtrSet& getUsedFunctions() const { - return UsedFunctions; + /// isUsedFunction - Return true if the functions in the llvm.used list. This + /// does not return true for things in llvm.compiler.used unless they are also + /// in llvm.used. + bool isUsedFunction(const Function *F) { + return UsedFunctions.count(F); } /// addCatchTypeInfo - Provide the catch typeinfo for a landing pad. @@ -603,7 +330,15 @@ public: /// of one is required to emit exception handling info. Function *getPersonality() const; - DIDeserializer *getDIDeserializer() { return &DR; } + /// setVariableDbgInfo - Collect information used to emit debugging information + /// of a variable. + void setVariableDbgInfo(MDNode *N, MDNode *L, unsigned S) { + if (N && L) + VariableDbgInfo[N] = std::make_pair(L, S); + } + + VariableDbgInfoMapTy &getVariableDbgInfo() { return VariableDbgInfo; } + }; // End class MachineModuleInfo } // End llvm namespace