• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
getContext()155   const MCContext &getContext() const { return Context; }
getContext()156   MCContext &getContext() { return Context; }
157 
getModule()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>
getObjFileInfo()175   Ty &getObjFileInfo() {
176     if (ObjFileMMI == nullptr)
177       ObjFileMMI = new Ty(*this);
178     return *static_cast<Ty*>(ObjFileMMI);
179   }
180 
181   template<typename Ty>
getObjFileInfo()182   const Ty &getObjFileInfo() const {
183     return const_cast<MachineModuleInfo*>(this)->getObjFileInfo<Ty>();
184   }
185 
186   /// Returns true if valid debug info is present.
hasDebugInfo()187   bool hasDebugInfo() const { return DbgInfoAvailable; }
setDebugInfoAvailability(bool avail)188   void setDebugInfoAvailability(bool avail) { DbgInfoAvailable = avail; }
189 
usesVAFloatArgument()190   bool usesVAFloatArgument() const {
191     return UsesVAFloatArgument;
192   }
193 
setUsesVAFloatArgument(bool b)194   void setUsesVAFloatArgument(bool b) {
195     UsesVAFloatArgument = b;
196   }
197 
usesMorestackAddr()198   bool usesMorestackAddr() const {
199     return UsesMorestackAddr;
200   }
201 
setUsesMorestackAddr(bool b)202   void setUsesMorestackAddr(bool b) {
203     UsesMorestackAddr = b;
204   }
205 
hasSplitStack()206   bool hasSplitStack() const {
207     return HasSplitStack;
208   }
209 
setHasSplitStack(bool b)210   void setHasSplitStack(bool b) {
211     HasSplitStack = b;
212   }
213 
hasNosplitStack()214   bool hasNosplitStack() const {
215     return HasNosplitStack;
216   }
217 
setHasNosplitStack(bool b)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.
getAddrLabelSymbol(const BasicBlock * BB)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.
setCurrentCallSite(unsigned Site)245   void setCurrentCallSite(unsigned Site) { CurCallSite = Site; }
246 
247   /// Get the call site currently being processed, if any.  return zero if
248   /// none.
getCurrentCallSite()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.
getPersonalities()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
272