contrib/llvm/include/llvm/CodeGen/MachineModuleInfo.h

   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/ADT/ArrayRef.h"
  35 #include "llvm/ADT/DenseMap.h"
  36 #include "llvm/ADT/PointerIntPair.h"
  37 #include "llvm/MC/MCContext.h"
  38 #include "llvm/MC/MCSymbol.h"
  39 #include "llvm/Pass.h"
  40 #include <memory>
  41 #include <utility>
  42 #include <vector>
  43
  44 namespace llvm {
  45
  46 class BasicBlock;
  47 class CallInst;
  48 class Function;
  49 class MachineFunction;
  50 class MMIAddrLabelMap;
  51 class Module;
  52 class TargetMachine;
  53
  54 //===----------------------------------------------------------------------===//
  55 /// This class can be derived from and used by targets to hold private
  56 /// target-specific information for each Module.  Objects of type are
  57 /// accessed/created with MMI::getInfo and destroyed when the MachineModuleInfo
  58 /// is destroyed.
  59 ///
  60 class MachineModuleInfoImpl {
  61 public:
  62   using StubValueTy = PointerIntPair<MCSymbol *, 1, bool>;
  63   using SymbolListTy = std::vector<std::pair<MCSymbol *, StubValueTy>>;
  64
  65   virtual ~MachineModuleInfoImpl();
  66
  67 protected:
  68   /// Return the entries from a DenseMap in a deterministic sorted orer.
  69   /// Clears the map.
  70   static SymbolListTy getSortedStubs(DenseMap<MCSymbol*, StubValueTy>&);
  71 };
  72
  73 //===----------------------------------------------------------------------===//
  74 /// This class contains meta information specific to a module.  Queries can be
  75 /// made by different debugging and exception handling schemes and reformated
  76 /// for specific use.
  77 ///
  78 class MachineModuleInfo : public ImmutablePass {
  79   const TargetMachine &TM;
  80
  81   /// This is the MCContext used for the entire code generator.
  82   MCContext Context;
  83
  84   /// This is the LLVM Module being worked on.
  85   const Module *TheModule;
  86
  87   /// This is the object-file-format-specific implementation of
  88   /// MachineModuleInfoImpl, which lets targets accumulate whatever info they
  89   /// want.
  90   MachineModuleInfoImpl *ObjFileMMI;
  91
  92   /// \name Exception Handling
  93   /// \{
  94
  95   /// Vector of all personality functions ever seen. Used to emit common EH
  96   /// frames.
  97   std::vector<const Function *> Personalities;
  98
  99   /// The current call site index being processed, if any. 0 if none.
 100   unsigned CurCallSite;
 101
 102   /// \}
 103
 104   /// This map keeps track of which symbol is being used for the specified
 105   /// basic block's address of label.
 106   MMIAddrLabelMap *AddrLabelSymbols;
 107
 108   // TODO: Ideally, what we'd like is to have a switch that allows emitting
 109   // synchronous (precise at call-sites only) CFA into .eh_frame. However,
 110   // even under this switch, we'd like .debug_frame to be precise when using
 111   // -g. At this moment, there's no way to specify that some CFI directives
 112   // go into .eh_frame only, while others go into .debug_frame only.
 113
 114   /// True if debugging information is available in this module.
 115   bool DbgInfoAvailable;
 116
 117   /// True if this module calls VarArg function with floating-point arguments.
 118   /// This is used to emit an undefined reference to _fltused on Windows
 119   /// targets.
 120   bool UsesVAFloatArgument;
 121
 122   /// True if the module calls the __morestack function indirectly, as is
 123   /// required under the large code model on x86. This is used to emit
 124   /// a definition of a symbol, __morestack_addr, containing the address. See
 125   /// comments in lib/Target/X86/X86FrameLowering.cpp for more details.
 126   bool UsesMorestackAddr;
 127
 128   /// True if the module contains split-stack functions. This is used to
 129   /// emit .note.GNU-split-stack section as required by the linker for
 130   /// special handling split-stack function calling no-split-stack function.
 131   bool HasSplitStack;
 132
 133   /// True if the module contains no-split-stack functions. This is used to
 134   /// emit .note.GNU-no-split-stack section when it also contains split-stack
 135   /// functions.
 136   bool HasNosplitStack;
 137
 138   /// Maps IR Functions to their corresponding MachineFunctions.
 139   DenseMap<const Function*, std::unique_ptr<MachineFunction>> MachineFunctions;
 140   /// Next unique number available for a MachineFunction.
 141   unsigned NextFnNum = 0;
 142   const Function *LastRequest = nullptr; ///< Used for shortcut/cache.
 143   MachineFunction *LastResult = nullptr; ///< Used for shortcut/cache.
 144
 145 public:
 146   static char ID; // Pass identification, replacement for typeid
 147
 148   explicit MachineModuleInfo(const TargetMachine *TM = nullptr);
 149   ~MachineModuleInfo() override;
 150
 151   // Initialization and Finalization
 152   bool doInitialization(Module &) override;
 153   bool doFinalization(Module &) override;
 154
 155   const MCContext &getContext() const { return Context; }
 156   MCContext &getContext() { return Context; }
 157
 158   const Module *getModule() const { return TheModule; }
 159
 160   /// Returns the MachineFunction constructed for the IR function \p F.
 161   /// Creates a new MachineFunction if none exists yet.
 162   MachineFunction &getOrCreateMachineFunction(const Function &F);
 163
 164   /// \bried Returns the MachineFunction associated to IR function \p F if there
 165   /// is one, otherwise nullptr.
 166   MachineFunction *getMachineFunction(const Function &F) const;
 167
 168   /// Delete the MachineFunction \p MF and reset the link in the IR Function to
 169   /// Machine Function map.
 170   void deleteMachineFunctionFor(Function &F);
 171
 172   /// Keep track of various per-function pieces of information for backends
 173   /// that would like to do so.
 174   template<typename Ty>
 175   Ty &getObjFileInfo() {
 176     if (ObjFileMMI == nullptr)
 177       ObjFileMMI = new Ty(*this);
 178     return *static_cast<Ty*>(ObjFileMMI);
 179   }
 180
 181   template<typename Ty>
 182   const Ty &getObjFileInfo() const {
 183     return const_cast<MachineModuleInfo*>(this)->getObjFileInfo<Ty>();
 184   }
 185
 186   /// Returns true if valid debug info is present.
 187   bool hasDebugInfo() const { return DbgInfoAvailable; }
 188   void setDebugInfoAvailability(bool avail) { DbgInfoAvailable = avail; }
 189
 190   bool usesVAFloatArgument() const {
 191     return UsesVAFloatArgument;
 192   }
 193
 194   void setUsesVAFloatArgument(bool b) {
 195     UsesVAFloatArgument = b;
 196   }
 197
 198   bool usesMorestackAddr() const {
 199     return UsesMorestackAddr;
 200   }
 201
 202   void setUsesMorestackAddr(bool b) {
 203     UsesMorestackAddr = b;
 204   }
 205
 206   bool hasSplitStack() const {
 207     return HasSplitStack;
 208   }
 209
 210   void setHasSplitStack(bool b) {
 211     HasSplitStack = b;
 212   }
 213
 214   bool hasNosplitStack() const {
 215     return HasNosplitStack;
 216   }
 217
 218   void setHasNosplitStack(bool b) {
 219     HasNosplitStack = b;
 220   }
 221
 222   /// Return the symbol to be used for the specified basic block when its
 223   /// address is taken.  This cannot be its normal LBB label because the block
 224   /// may be accessed outside its containing function.
 225   MCSymbol *getAddrLabelSymbol(const BasicBlock *BB) {
 226     return getAddrLabelSymbolToEmit(BB).front();
 227   }
 228
 229   /// Return the symbol to be used for the specified basic block when its
 230   /// address is taken.  If other blocks were RAUW'd to this one, we may have
 231   /// to emit them as well, return the whole set.
 232   ArrayRef<MCSymbol *> getAddrLabelSymbolToEmit(const BasicBlock *BB);
 233
 234   /// If the specified function has had any references to address-taken blocks
 235   /// generated, but the block got deleted, return the symbol now so we can
 236   /// emit it.  This prevents emitting a reference to a symbol that has no
 237   /// definition.
 238   void takeDeletedSymbolsForFunction(const Function *F,
 239                                      std::vector<MCSymbol*> &Result);
 240
 241   /// \name Exception Handling
 242   /// \{
 243
 244   /// Set the call site currently being processed.
 245   void setCurrentCallSite(unsigned Site) { CurCallSite = Site; }
 246
 247   /// Get the call site currently being processed, if any.  return zero if
 248   /// none.
 249   unsigned getCurrentCallSite() { return CurCallSite; }
 250
 251   /// Provide the personality function for the exception information.
 252   void addPersonality(const Function *Personality);
 253
 254   /// Return array of personality functions ever seen.
 255   const std::vector<const Function *>& getPersonalities() const {
 256     return Personalities;
 257   }
 258   /// \}
 259 }; // End class MachineModuleInfo
 260
 261 //===- MMI building helpers -----------------------------------------------===//
 262
 263 /// Determine if any floating-point values are being passed to this variadic
 264 /// function, and set the MachineModuleInfo's usesVAFloatArgument flag if so.
 265 /// This flag is used to emit an undefined reference to _fltused on Windows,
 266 /// which will link in MSVCRT's floating-point support.
 267 void computeUsesVAFloatArgument(const CallInst &I, MachineModuleInfo &MMI);
 268
 269 } // end namespace llvm
 270
 271 #endif // LLVM_CODEGEN_MACHINEMODULEINFO_H