X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FCodeGen%2FMachineModuleInfo.h;h=17da43b7d6216e6728daf2c96d5fc231d1a45849;hb=421ccd9892178e741e24c96cef4304262475255d;hp=f2a2b7b674c4c6afbe032666b295d6cbf8cfc727;hpb=914c970899ce3281a8d14d924ec1bfe335624ac6;p=oota-llvm.git diff --git a/include/llvm/CodeGen/MachineModuleInfo.h b/include/llvm/CodeGen/MachineModuleInfo.h index f2a2b7b674c..17da43b7d62 100644 --- a/include/llvm/CodeGen/MachineModuleInfo.h +++ b/include/llvm/CodeGen/MachineModuleInfo.h @@ -31,313 +31,83 @@ #ifndef LLVM_CODEGEN_MACHINEMODULEINFO_H #define LLVM_CODEGEN_MACHINEMODULEINFO_H -#include "llvm/GlobalValue.h" #include "llvm/Pass.h" +#include "llvm/GlobalValue.h" +#include "llvm/Metadata.h" +#include "llvm/CodeGen/MachineLocation.h" +#include "llvm/MC/MCContext.h" +#include "llvm/Support/Dwarf.h" +#include "llvm/Support/DebugLoc.h" +#include "llvm/Support/ValueHandle.h" +#include "llvm/System/DataTypes.h" #include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/PointerIntPair.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/UniqueVector.h" -#include "llvm/Support/DataTypes.h" -#include "llvm/Support/Dwarf.h" namespace llvm { //===----------------------------------------------------------------------===// // Forward declarations. -class AnchoredDesc; -class CompileUnitDesc; class Constant; -class DebugInfoDesc; class GlobalVariable; +class MDNode; 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; +/// 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: - const DenseMap &getGlobalDescs() const { - return GlobalDescs; - } - - /// Deserialize - Reconstitute a GlobalVariable into it's component - /// DebugInfoDesc objects. - DebugInfoDesc *Deserialize(Value *V); - DebugInfoDesc *Deserialize(GlobalVariable *GV); + typedef PointerIntPair StubValueTy; + virtual ~MachineModuleInfoImpl(); + typedef std::vector > SymbolListTy; +protected: + static SymbolListTy GetSortedStubs(const DenseMap&); }; - -//===----------------------------------------------------------------------===// -/// 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. - -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); } -}; //===----------------------------------------------------------------------===// /// LandingPadInfo - This structure is used to retain landing pad info for /// the current function. /// struct LandingPadInfo { - MachineBasicBlock *LandingPadBlock; // Landing pad block. - SmallVector BeginLabels; // Labels prior to invoke. - SmallVector EndLabels; // Labels after invoke. - unsigned LandingPadLabel; // Label at beginning of landing pad. - Function *Personality; // Personality function. - std::vector TypeIds; // List of type ids (filters negative) + MachineBasicBlock *LandingPadBlock; // Landing pad block. + SmallVector BeginLabels; // Labels prior to invoke. + SmallVector EndLabels; // Labels after invoke. + MCSymbol *LandingPadLabel; // Label at beginning of landing pad. + Function *Personality; // Personality function. + std::vector TypeIds; // List of type ids (filters negative) explicit LandingPadInfo(MachineBasicBlock *MBB) - : LandingPadBlock(MBB) - , LandingPadLabel(0) - , Personality(NULL) - {} + : LandingPadBlock(MBB), LandingPadLabel(0), Personality(0) {} }; +class MMIAddrLabelMap; + //===----------------------------------------------------------------------===// /// MachineModuleInfo - This class contains meta information specific to a /// module. Queries can be made by different debugging and exception handling /// schemes and reformated for specific use. /// class MachineModuleInfo : public ImmutablePass { -private: - // Use the same deserializer/verifier for the module. - DIDeserializer DR; - DIVerifier VR; - - // 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; + /// Context - This is the MCContext used for the entire code generator. + MCContext Context; - // 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; + /// TheModule - This is the LLVM Module being worked on. + Module *TheModule; + /// ObjFileMMI - This is the object-file-format-specific implementation of + /// MachineModuleInfoImpl, which lets targets accumulate whatever info they + /// want. + MachineModuleInfoImpl *ObjFileMMI; + // FrameMoves - List of moves done by a function's prolog. Used to construct // frame maps by debug and exception handling consumers. std::vector FrameMoves; @@ -345,7 +115,14 @@ private: // LandingPads - List of LandingPadInfo describing the landing pad information // in the current function. std::vector LandingPads; - + + // Map of invoke call site index values to associated begin EH_LABEL for + // the current function. + DenseMap CallSiteMap; + + // The current call site index being processed, if any. 0 if none. + unsigned CurCallSite; + // TypeInfos - List of C++ TypeInfo used in the current function. // std::vector TypeInfos; @@ -363,46 +140,62 @@ 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; + + /// AddrLabelSymbols - This map keeps track of which symbol is being used for + /// the specified basic block's address of label. + MMIAddrLabelMap *AddrLabelSymbols; + 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 - MachineModuleInfo(); + typedef std::pair UnsignedDebugLocPair; + typedef SmallVector, UnsignedDebugLocPair>, 4> + VariableDbgInfoMapTy; + VariableDbgInfoMapTy VariableDbgInfo; + + MachineModuleInfo(); // DUMMY CONSTRUCTOR, DO NOT CALL. + MachineModuleInfo(const MCAsmInfo &MAI); // Real constructor. ~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); - + /// EndFunction - Discard function meta information. /// void EndFunction(); + + const MCContext &getContext() const { return Context; } + MCContext &getContext() { return Context; } - /// getDescFor - Convert a Value to a debug information descriptor. - /// - // FIXME - use new Value type when available. - DebugInfoDesc *getDescFor(Value *V); + void setModule(Module *M) { TheModule = M; } + Module *getModule() const { return TheModule; } - /// Verify - Verify that a Value is debug information descriptor. + /// getInfo - Keep track of various per-function pieces of information for + /// backends that would like to do so. /// - 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 + Ty &getObjFileInfo() { + if (ObjFileMMI == 0) + ObjFileMMI = new Ty(*this); + return *static_cast(ObjFileMMI); + } + + template + const Ty &getObjFileInfo() const { + return const_cast(this)->getObjFileInfo(); + } /// AnalyzeModule - Scan the module for global debug information. /// @@ -410,119 +203,39 @@ 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; } bool callsUnwindInit() const { return CallsUnwindInit; } void setCallsUnwindInit(bool b) { CallsUnwindInit = b; } - /// NextLabelID - Return the next unique label id. - /// - unsigned NextLabelID() { - unsigned ID = (unsigned)LabelIDList.size() + 1; - LabelIDList.push_back(ID); - 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) { - // Remap to zero to indicate deletion. - RemapLabel(LabelID, 0); - } - - /// RemapLabel - Indicate that a label has been merged into another. - /// - void RemapLabel(unsigned OldLabelID, unsigned NewLabelID) { - assert(0 < OldLabelID && OldLabelID <= LabelIDList.size() && - "Old label ID out of range."); - assert(NewLabelID <= LabelIDList.size() && - "New label ID out of range."); - LabelIDList[OldLabelID - 1] = NewLabelID; - } - - /// MappedLabel - Find out the label's final ID. Zero indicates deletion. - /// ID != Mapped ID indicates that the label was folded into another label. - unsigned MappedLabel(unsigned LabelID) const { - assert(LabelID <= LabelIDList.size() && "Debug label ID out of range."); - 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; - } - - /// getSourceLines - Return a vector of source lines. - /// - const std::vector &getSourceLines() const { - return Lines; - } - - /// 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. std::vector &getFrameMoves() { return FrameMoves; } - //===-EH-----------------------------------------------------------------===// + /// getAddrLabelSymbol - Return the symbol to be used for the specified basic + /// block when its address is taken. This cannot be its normal LBB label + /// because the block may be accessed outside its containing function. + MCSymbol *getAddrLabelSymbol(const BasicBlock *BB); + + /// getAddrLabelSymbolToEmit - Return the symbol to be used for the specified + /// basic block when its address is taken. If other blocks were RAUW'd to + /// this one, we may have to emit them as well, return the whole set. + std::vector getAddrLabelSymbolToEmit(const BasicBlock *BB); + + /// takeDeletedSymbolsForFunction - If the specified function has had any + /// references to address-taken blocks generated, but the block got deleted, + /// return the symbol now so we can emit it. This prevents emitting a + /// reference to a symbol that has no definition. + void takeDeletedSymbolsForFunction(const Function *F, + std::vector &Result); + + + //===- EH ---------------------------------------------------------------===// /// getOrCreateLandingPadInfo - Find or create an LandingPadInfo for the /// specified MachineBasicBlock. @@ -530,12 +243,12 @@ public: /// addInvoke - Provide the begin and end labels of an invoke style call and /// associate it with a try landing pad block. - void addInvoke(MachineBasicBlock *LandingPad, unsigned BeginLabel, - unsigned EndLabel); + void addInvoke(MachineBasicBlock *LandingPad, + MCSymbol *BeginLabel, MCSymbol *EndLabel); /// addLandingPad - Add a new panding pad. Returns the label ID for the /// landing pad entry. - unsigned addLandingPad(MachineBasicBlock *LandingPad); + MCSymbol *addLandingPad(MachineBasicBlock *LandingPad); /// addPersonality - Provide the personality function for the exception /// information. @@ -550,9 +263,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. @@ -586,7 +301,26 @@ public: const std::vector &getLandingPads() const { return LandingPads; } - + + /// setCallSiteBeginLabel - Map the begin label for a call site + void setCallSiteBeginLabel(MCSymbol *BeginLabel, unsigned Site) { + CallSiteMap[BeginLabel] = Site; + } + + /// getCallSiteBeginLabel - Get the call site number for a begin label + unsigned getCallSiteBeginLabel(MCSymbol *BeginLabel) { + assert(CallSiteMap.count(BeginLabel) && + "Missing call site number for EH_LABEL!"); + return CallSiteMap[BeginLabel]; + } + + /// setCurrentCallSite - Set the call site currently being processed. + void setCurrentCallSite(unsigned Site) { CurCallSite = Site; } + + /// getCurrentCallSite - Get the call site currently being processed, if any. + /// return zero if none. + unsigned getCurrentCallSite(void) { return CurCallSite; } + /// getTypeInfos - Return a reference to the C++ typeinfo for the current /// function. const std::vector &getTypeInfos() const { @@ -603,7 +337,14 @@ 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, unsigned Slot, DebugLoc Loc) { + VariableDbgInfo.push_back(std::make_pair(N, std::make_pair(Slot, Loc))); + } + + VariableDbgInfoMapTy &getVariableDbgInfo() { return VariableDbgInfo; } + }; // End class MachineModuleInfo } // End llvm namespace