Home | History | Annotate | Download | only in CodeGen
      1 //===-- llvm/CodeGen/MachineModuleInfo.h ------------------------*- C++ -*-===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // Collect meta information for a module.  This information should be in a
     11 // neutral form that can be used by different debugging and exception handling
     12 // schemes.
     13 //
     14 // The organization of information is primarily clustered around the source
     15 // compile units.  The main exception is source line correspondence where
     16 // inlining may interleave code from various compile units.
     17 //
     18 // The following information can be retrieved from the MachineModuleInfo.
     19 //
     20 //  -- Source directories - Directories are uniqued based on their canonical
     21 //     string and assigned a sequential numeric ID (base 1.)
     22 //  -- Source files - Files are also uniqued based on their name and directory
     23 //     ID.  A file ID is sequential number (base 1.)
     24 //  -- Source line correspondence - A vector of file ID, line#, column# triples.
     25 //     A DEBUG_LOCATION instruction is generated  by the DAG Legalizer
     26 //     corresponding to each entry in the source line list.  This allows a debug
     27 //     emitter to generate labels referenced by debug information tables.
     28 //
     29 //===----------------------------------------------------------------------===//
     30 
     31 #ifndef LLVM_CODEGEN_MACHINEMODULEINFO_H
     32 #define LLVM_CODEGEN_MACHINEMODULEINFO_H
     33 
     34 #include "llvm/Pass.h"
     35 #include "llvm/GlobalValue.h"
     36 #include "llvm/Metadata.h"
     37 #include "llvm/MC/MachineLocation.h"
     38 #include "llvm/MC/MCContext.h"
     39 #include "llvm/Support/Dwarf.h"
     40 #include "llvm/Support/DebugLoc.h"
     41 #include "llvm/Support/ValueHandle.h"
     42 #include "llvm/Support/DataTypes.h"
     43 #include "llvm/ADT/DenseMap.h"
     44 #include "llvm/ADT/PointerIntPair.h"
     45 #include "llvm/ADT/SmallPtrSet.h"
     46 #include "llvm/ADT/SmallVector.h"
     47 
     48 namespace llvm {
     49 
     50 //===----------------------------------------------------------------------===//
     51 // Forward declarations.
     52 class Constant;
     53 class GlobalVariable;
     54 class MDNode;
     55 class MMIAddrLabelMap;
     56 class MachineBasicBlock;
     57 class MachineFunction;
     58 class Module;
     59 class PointerType;
     60 class StructType;
     61 
     62 //===----------------------------------------------------------------------===//
     63 /// LandingPadInfo - This structure is used to retain landing pad info for
     64 /// the current function.
     65 ///
     66 struct LandingPadInfo {
     67   MachineBasicBlock *LandingPadBlock;    // Landing pad block.
     68   SmallVector<MCSymbol*, 1> BeginLabels; // Labels prior to invoke.
     69   SmallVector<MCSymbol*, 1> EndLabels;   // Labels after invoke.
     70   MCSymbol *LandingPadLabel;             // Label at beginning of landing pad.
     71   const Function *Personality;           // Personality function.
     72   std::vector<int> TypeIds;              // List of type ids (filters negative)
     73 
     74   explicit LandingPadInfo(MachineBasicBlock *MBB)
     75     : LandingPadBlock(MBB), LandingPadLabel(0), Personality(0) {}
     76 };
     77 
     78 //===----------------------------------------------------------------------===//
     79 /// MachineModuleInfoImpl - This class can be derived from and used by targets
     80 /// to hold private target-specific information for each Module.  Objects of
     81 /// type are accessed/created with MMI::getInfo and destroyed when the
     82 /// MachineModuleInfo is destroyed.
     83 ///
     84 class MachineModuleInfoImpl {
     85 public:
     86   typedef PointerIntPair<MCSymbol*, 1, bool> StubValueTy;
     87   virtual ~MachineModuleInfoImpl();
     88   typedef std::vector<std::pair<MCSymbol*, StubValueTy> > SymbolListTy;
     89 protected:
     90   static SymbolListTy GetSortedStubs(const DenseMap<MCSymbol*, StubValueTy>&);
     91 };
     92 
     93 //===----------------------------------------------------------------------===//
     94 /// MachineModuleInfo - This class contains meta information specific to a
     95 /// module.  Queries can be made by different debugging and exception handling
     96 /// schemes and reformated for specific use.
     97 ///
     98 class MachineModuleInfo : public ImmutablePass {
     99   /// Context - This is the MCContext used for the entire code generator.
    100   MCContext Context;
    101 
    102   /// TheModule - This is the LLVM Module being worked on.
    103   const Module *TheModule;
    104 
    105   /// ObjFileMMI - This is the object-file-format-specific implementation of
    106   /// MachineModuleInfoImpl, which lets targets accumulate whatever info they
    107   /// want.
    108   MachineModuleInfoImpl *ObjFileMMI;
    109 
    110   /// FrameMoves - List of moves done by a function's prolog.  Used to construct
    111   /// frame maps by debug and exception handling consumers.
    112   std::vector<MachineMove> FrameMoves;
    113 
    114   /// CompactUnwindEncoding - If the target supports it, this is the compact
    115   /// unwind encoding. It replaces a function's CIE and FDE.
    116   uint32_t CompactUnwindEncoding;
    117 
    118   /// LandingPads - List of LandingPadInfo describing the landing pad
    119   /// information in the current function.
    120   std::vector<LandingPadInfo> LandingPads;
    121 
    122   /// LPadToCallSiteMap - Map a landing pad's EH symbol to the call site
    123   /// indexes.
    124   DenseMap<MCSymbol*, SmallVector<unsigned, 4> > LPadToCallSiteMap;
    125 
    126   /// CallSiteMap - Map of invoke call site index values to associated begin
    127   /// EH_LABEL for the current function.
    128   DenseMap<MCSymbol*, unsigned> CallSiteMap;
    129 
    130   /// CurCallSite - The current call site index being processed, if any. 0 if
    131   /// none.
    132   unsigned CurCallSite;
    133 
    134   /// TypeInfos - List of C++ TypeInfo used in the current function.
    135   std::vector<const GlobalVariable *> TypeInfos;
    136 
    137   /// FilterIds - List of typeids encoding filters used in the current function.
    138   std::vector<unsigned> FilterIds;
    139 
    140   /// FilterEnds - List of the indices in FilterIds corresponding to filter
    141   /// terminators.
    142   std::vector<unsigned> FilterEnds;
    143 
    144   /// Personalities - Vector of all personality functions ever seen. Used to
    145   /// emit common EH frames.
    146   std::vector<const Function *> Personalities;
    147 
    148   /// UsedFunctions - The functions in the @llvm.used list in a more easily
    149   /// searchable format.  This does not include the functions in
    150   /// llvm.compiler.used.
    151   SmallPtrSet<const Function *, 32> UsedFunctions;
    152 
    153   /// AddrLabelSymbols - This map keeps track of which symbol is being used for
    154   /// the specified basic block's address of label.
    155   MMIAddrLabelMap *AddrLabelSymbols;
    156 
    157   bool CallsEHReturn;
    158   bool CallsUnwindInit;
    159 
    160   /// DbgInfoAvailable - True if debugging information is available
    161   /// in this module.
    162   bool DbgInfoAvailable;
    163 
    164   /// UsesVAFloatArgument - True if this module calls VarArg function with
    165   /// floating-point arguments.  This is used to emit an undefined reference
    166   /// to _fltused on Windows targets.
    167   bool UsesVAFloatArgument;
    168 
    169 public:
    170   static char ID; // Pass identification, replacement for typeid
    171 
    172   typedef std::pair<unsigned, DebugLoc> UnsignedDebugLocPair;
    173   typedef SmallVector<std::pair<TrackingVH<MDNode>, UnsignedDebugLocPair>, 4>
    174     VariableDbgInfoMapTy;
    175   VariableDbgInfoMapTy VariableDbgInfo;
    176 
    177   MachineModuleInfo();  // DUMMY CONSTRUCTOR, DO NOT CALL.
    178   // Real constructor.
    179   MachineModuleInfo(const MCAsmInfo &MAI, const MCRegisterInfo &MRI,
    180                     const MCObjectFileInfo *MOFI);
    181   ~MachineModuleInfo();
    182 
    183   bool doInitialization();
    184   bool doFinalization();
    185 
    186   /// EndFunction - Discard function meta information.
    187   ///
    188   void EndFunction();
    189 
    190   const MCContext &getContext() const { return Context; }
    191   MCContext &getContext() { return Context; }
    192 
    193   void setModule(const Module *M) { TheModule = M; }
    194   const Module *getModule() const { return TheModule; }
    195 
    196   /// getInfo - Keep track of various per-function pieces of information for
    197   /// backends that would like to do so.
    198   ///
    199   template<typename Ty>
    200   Ty &getObjFileInfo() {
    201     if (ObjFileMMI == 0)
    202       ObjFileMMI = new Ty(*this);
    203     return *static_cast<Ty*>(ObjFileMMI);
    204   }
    205 
    206   template<typename Ty>
    207   const Ty &getObjFileInfo() const {
    208     return const_cast<MachineModuleInfo*>(this)->getObjFileInfo<Ty>();
    209   }
    210 
    211   /// AnalyzeModule - Scan the module for global debug information.
    212   ///
    213   void AnalyzeModule(const Module &M);
    214 
    215   /// hasDebugInfo - Returns true if valid debug info is present.
    216   ///
    217   bool hasDebugInfo() const { return DbgInfoAvailable; }
    218   void setDebugInfoAvailability(bool avail) { DbgInfoAvailable = avail; }
    219 
    220   bool callsEHReturn() const { return CallsEHReturn; }
    221   void setCallsEHReturn(bool b) { CallsEHReturn = b; }
    222 
    223   bool callsUnwindInit() const { return CallsUnwindInit; }
    224   void setCallsUnwindInit(bool b) { CallsUnwindInit = b; }
    225 
    226   bool usesVAFloatArgument() const {
    227     return UsesVAFloatArgument;
    228   }
    229 
    230   void setUsesVAFloatArgument(bool b) {
    231     UsesVAFloatArgument = b;
    232   }
    233 
    234   /// getFrameMoves - Returns a reference to a list of moves done in the current
    235   /// function's prologue.  Used to construct frame maps for debug and exception
    236   /// handling comsumers.
    237   std::vector<MachineMove> &getFrameMoves() { return FrameMoves; }
    238 
    239   /// getCompactUnwindEncoding - Returns the compact unwind encoding for a
    240   /// function if the target supports the encoding. This encoding replaces a
    241   /// function's CIE and FDE.
    242   uint32_t getCompactUnwindEncoding() const { return CompactUnwindEncoding; }
    243 
    244   /// setCompactUnwindEncoding - Set the compact unwind encoding for a function
    245   /// if the target supports the encoding.
    246   void setCompactUnwindEncoding(uint32_t Enc) { CompactUnwindEncoding = Enc; }
    247 
    248   /// getAddrLabelSymbol - Return the symbol to be used for the specified basic
    249   /// block when its address is taken.  This cannot be its normal LBB label
    250   /// because the block may be accessed outside its containing function.
    251   MCSymbol *getAddrLabelSymbol(const BasicBlock *BB);
    252 
    253   /// getAddrLabelSymbolToEmit - Return the symbol to be used for the specified
    254   /// basic block when its address is taken.  If other blocks were RAUW'd to
    255   /// this one, we may have to emit them as well, return the whole set.
    256   std::vector<MCSymbol*> getAddrLabelSymbolToEmit(const BasicBlock *BB);
    257 
    258   /// takeDeletedSymbolsForFunction - If the specified function has had any
    259   /// references to address-taken blocks generated, but the block got deleted,
    260   /// return the symbol now so we can emit it.  This prevents emitting a
    261   /// reference to a symbol that has no definition.
    262   void takeDeletedSymbolsForFunction(const Function *F,
    263                                      std::vector<MCSymbol*> &Result);
    264 
    265 
    266   //===- EH ---------------------------------------------------------------===//
    267 
    268   /// getOrCreateLandingPadInfo - Find or create an LandingPadInfo for the
    269   /// specified MachineBasicBlock.
    270   LandingPadInfo &getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad);
    271 
    272   /// addInvoke - Provide the begin and end labels of an invoke style call and
    273   /// associate it with a try landing pad block.
    274   void addInvoke(MachineBasicBlock *LandingPad,
    275                  MCSymbol *BeginLabel, MCSymbol *EndLabel);
    276 
    277   /// addLandingPad - Add a new panding pad.  Returns the label ID for the
    278   /// landing pad entry.
    279   MCSymbol *addLandingPad(MachineBasicBlock *LandingPad);
    280 
    281   /// addPersonality - Provide the personality function for the exception
    282   /// information.
    283   void addPersonality(MachineBasicBlock *LandingPad,
    284                       const Function *Personality);
    285 
    286   /// getPersonalityIndex - Get index of the current personality function inside
    287   /// Personalitites array
    288   unsigned getPersonalityIndex() const;
    289 
    290   /// getPersonalities - Return array of personality functions ever seen.
    291   const std::vector<const Function *>& getPersonalities() const {
    292     return Personalities;
    293   }
    294 
    295   /// isUsedFunction - Return true if the functions in the llvm.used list.  This
    296   /// does not return true for things in llvm.compiler.used unless they are also
    297   /// in llvm.used.
    298   bool isUsedFunction(const Function *F) {
    299     return UsedFunctions.count(F);
    300   }
    301 
    302   /// addCatchTypeInfo - Provide the catch typeinfo for a landing pad.
    303   ///
    304   void addCatchTypeInfo(MachineBasicBlock *LandingPad,
    305                         ArrayRef<const GlobalVariable *> TyInfo);
    306 
    307   /// addFilterTypeInfo - Provide the filter typeinfo for a landing pad.
    308   ///
    309   void addFilterTypeInfo(MachineBasicBlock *LandingPad,
    310                          ArrayRef<const GlobalVariable *> TyInfo);
    311 
    312   /// addCleanup - Add a cleanup action for a landing pad.
    313   ///
    314   void addCleanup(MachineBasicBlock *LandingPad);
    315 
    316   /// getTypeIDFor - Return the type id for the specified typeinfo.  This is
    317   /// function wide.
    318   unsigned getTypeIDFor(const GlobalVariable *TI);
    319 
    320   /// getFilterIDFor - Return the id of the filter encoded by TyIds.  This is
    321   /// function wide.
    322   int getFilterIDFor(std::vector<unsigned> &TyIds);
    323 
    324   /// TidyLandingPads - Remap landing pad labels and remove any deleted landing
    325   /// pads.
    326   void TidyLandingPads(DenseMap<MCSymbol*, uintptr_t> *LPMap = 0);
    327 
    328   /// getLandingPads - Return a reference to the landing pad info for the
    329   /// current function.
    330   const std::vector<LandingPadInfo> &getLandingPads() const {
    331     return LandingPads;
    332   }
    333 
    334   /// setCallSiteLandingPad - Map the landing pad's EH symbol to the call
    335   /// site indexes.
    336   void setCallSiteLandingPad(MCSymbol *Sym, ArrayRef<unsigned> Sites);
    337 
    338   /// getCallSiteLandingPad - Get the call site indexes for a landing pad EH
    339   /// symbol.
    340   SmallVectorImpl<unsigned> &getCallSiteLandingPad(MCSymbol *Sym) {
    341     assert(hasCallSiteLandingPad(Sym) &&
    342            "missing call site number for landing pad!");
    343     return LPadToCallSiteMap[Sym];
    344   }
    345 
    346   /// hasCallSiteLandingPad - Return true if the landing pad Eh symbol has an
    347   /// associated call site.
    348   bool hasCallSiteLandingPad(MCSymbol *Sym) {
    349     return !LPadToCallSiteMap[Sym].empty();
    350   }
    351 
    352   /// setCallSiteBeginLabel - Map the begin label for a call site.
    353   void setCallSiteBeginLabel(MCSymbol *BeginLabel, unsigned Site) {
    354     CallSiteMap[BeginLabel] = Site;
    355   }
    356 
    357   /// getCallSiteBeginLabel - Get the call site number for a begin label.
    358   unsigned getCallSiteBeginLabel(MCSymbol *BeginLabel) {
    359     assert(hasCallSiteBeginLabel(BeginLabel) &&
    360            "Missing call site number for EH_LABEL!");
    361     return CallSiteMap[BeginLabel];
    362   }
    363 
    364   /// hasCallSiteBeginLabel - Return true if the begin label has a call site
    365   /// number associated with it.
    366   bool hasCallSiteBeginLabel(MCSymbol *BeginLabel) {
    367     return CallSiteMap[BeginLabel] != 0;
    368   }
    369 
    370   /// setCurrentCallSite - Set the call site currently being processed.
    371   void setCurrentCallSite(unsigned Site) { CurCallSite = Site; }
    372 
    373   /// getCurrentCallSite - Get the call site currently being processed, if any.
    374   /// return zero if none.
    375   unsigned getCurrentCallSite(void) { return CurCallSite; }
    376 
    377   /// getTypeInfos - Return a reference to the C++ typeinfo for the current
    378   /// function.
    379   const std::vector<const GlobalVariable *> &getTypeInfos() const {
    380     return TypeInfos;
    381   }
    382 
    383   /// getFilterIds - Return a reference to the typeids encoding filters used in
    384   /// the current function.
    385   const std::vector<unsigned> &getFilterIds() const {
    386     return FilterIds;
    387   }
    388 
    389   /// getPersonality - Return a personality function if available.  The presence
    390   /// of one is required to emit exception handling info.
    391   const Function *getPersonality() const;
    392 
    393   /// setVariableDbgInfo - Collect information used to emit debugging
    394   /// information of a variable.
    395   void setVariableDbgInfo(MDNode *N, unsigned Slot, DebugLoc Loc) {
    396     VariableDbgInfo.push_back(std::make_pair(N, std::make_pair(Slot, Loc)));
    397   }
    398 
    399   VariableDbgInfoMapTy &getVariableDbgInfo() { return VariableDbgInfo; }
    400 
    401 }; // End class MachineModuleInfo
    402 
    403 } // End llvm namespace
    404 
    405 #endif
    406