LLVM  10.0.0svn
MachineModuleInfo.h
Go to the documentation of this file.
1 //===-- llvm/CodeGen/MachineModuleInfo.h ------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Collect meta information for a module. This information should be in a
10 // neutral form that can be used by different debugging and exception handling
11 // schemes.
12 //
13 // The organization of information is primarily clustered around the source
14 // compile units. The main exception is source line correspondence where
15 // inlining may interleave code from various compile units.
16 //
17 // The following information can be retrieved from the MachineModuleInfo.
18 //
19 // -- Source directories - Directories are uniqued based on their canonical
20 // string and assigned a sequential numeric ID (base 1.)
21 // -- Source files - Files are also uniqued based on their name and directory
22 // ID. A file ID is sequential number (base 1.)
23 // -- Source line correspondence - A vector of file ID, line#, column# triples.
24 // A DEBUG_LOCATION instruction is generated by the DAG Legalizer
25 // corresponding to each entry in the source line list. This allows a debug
26 // emitter to generate labels referenced by debug information tables.
27 //
28 //===----------------------------------------------------------------------===//
29 
30 #ifndef LLVM_CODEGEN_MACHINEMODULEINFO_H
31 #define LLVM_CODEGEN_MACHINEMODULEINFO_H
32 
33 #include "llvm/ADT/ArrayRef.h"
34 #include "llvm/ADT/DenseMap.h"
36 #include "llvm/IR/PassManager.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 LLVMTargetMachine;
50 class MMIAddrLabelMap;
51 class MachineFunction;
52 class Module;
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 ///
61 public:
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.
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 ///
80  friend class MachineModuleAnalysis;
81 
82  const LLVMTargetMachine &TM;
83 
84  /// This is the MCContext used for the entire code generator.
86 
87  /// This is the LLVM Module being worked on.
88  const Module *TheModule;
89 
90  /// This is the object-file-format-specific implementation of
91  /// MachineModuleInfoImpl, which lets targets accumulate whatever info they
92  /// want.
93  MachineModuleInfoImpl *ObjFileMMI;
94 
95  /// \name Exception Handling
96  /// \{
97 
98  /// Vector of all personality functions ever seen. Used to emit common EH
99  /// frames.
100  std::vector<const Function *> Personalities;
101 
102  /// The current call site index being processed, if any. 0 if none.
103  unsigned CurCallSite;
104 
105  /// \}
106 
107  /// This map keeps track of which symbol is being used for the specified
108  /// basic block's address of label.
109  MMIAddrLabelMap *AddrLabelSymbols;
110 
111  // TODO: Ideally, what we'd like is to have a switch that allows emitting
112  // synchronous (precise at call-sites only) CFA into .eh_frame. However,
113  // even under this switch, we'd like .debug_frame to be precise when using
114  // -g. At this moment, there's no way to specify that some CFI directives
115  // go into .eh_frame only, while others go into .debug_frame only.
116 
117  /// True if debugging information is available in this module.
118  bool DbgInfoAvailable;
119 
120  /// True if this module is being built for windows/msvc, and uses floating
121  /// point. This is used to emit an undefined reference to _fltused.
122  bool UsesMSVCFloatingPoint;
123 
124  /// True if the module calls the __morestack function indirectly, as is
125  /// required under the large code model on x86. This is used to emit
126  /// a definition of a symbol, __morestack_addr, containing the address. See
127  /// comments in lib/Target/X86/X86FrameLowering.cpp for more details.
128  bool UsesMorestackAddr;
129 
130  /// True if the module contains split-stack functions. This is used to
131  /// emit .note.GNU-split-stack section as required by the linker for
132  /// special handling split-stack function calling no-split-stack function.
133  bool HasSplitStack;
134 
135  /// True if the module contains no-split-stack functions. This is used to
136  /// emit .note.GNU-no-split-stack section when it also contains split-stack
137  /// functions.
138  bool HasNosplitStack;
139 
140  /// Maps IR Functions to their corresponding MachineFunctions.
142  /// Next unique number available for a MachineFunction.
143  unsigned NextFnNum = 0;
144  const Function *LastRequest = nullptr; ///< Used for shortcut/cache.
145  MachineFunction *LastResult = nullptr; ///< Used for shortcut/cache.
146 
147  MachineModuleInfo &operator=(MachineModuleInfo &&MMII) = delete;
148 
149 public:
150  explicit MachineModuleInfo(const LLVMTargetMachine *TM = nullptr);
151 
153 
155 
156  void initialize();
157  void finalize();
158 
159  const LLVMTargetMachine &getTarget() const { return TM; }
160 
161  const MCContext &getContext() const { return Context; }
162  MCContext &getContext() { return Context; }
163 
164  const Module *getModule() const { return TheModule; }
165 
166  /// Returns the MachineFunction constructed for the IR function \p F.
167  /// Creates a new MachineFunction if none exists yet.
168  MachineFunction &getOrCreateMachineFunction(const Function &F);
169 
170  /// \bried Returns the MachineFunction associated to IR function \p F if there
171  /// is one, otherwise nullptr.
172  MachineFunction *getMachineFunction(const Function &F) const;
173 
174  /// Delete the MachineFunction \p MF and reset the link in the IR Function to
175  /// Machine Function map.
176  void deleteMachineFunctionFor(Function &F);
177 
178  /// Keep track of various per-function pieces of information for backends
179  /// that would like to do so.
180  template<typename Ty>
182  if (ObjFileMMI == nullptr)
183  ObjFileMMI = new Ty(*this);
184  return *static_cast<Ty*>(ObjFileMMI);
185  }
186 
187  template<typename Ty>
188  const Ty &getObjFileInfo() const {
189  return const_cast<MachineModuleInfo*>(this)->getObjFileInfo<Ty>();
190  }
191 
192  /// Returns true if valid debug info is present.
193  bool hasDebugInfo() const { return DbgInfoAvailable; }
194  void setDebugInfoAvailability(bool avail) { DbgInfoAvailable = avail; }
195 
196  bool usesMSVCFloatingPoint() const { return UsesMSVCFloatingPoint; }
197 
198  void setUsesMSVCFloatingPoint(bool b) { UsesMSVCFloatingPoint = b; }
199 
200  bool usesMorestackAddr() const {
201  return UsesMorestackAddr;
202  }
203 
204  void setUsesMorestackAddr(bool b) {
205  UsesMorestackAddr = b;
206  }
207 
208  bool hasSplitStack() const {
209  return HasSplitStack;
210  }
211 
212  void setHasSplitStack(bool b) {
213  HasSplitStack = b;
214  }
215 
216  bool hasNosplitStack() const {
217  return HasNosplitStack;
218  }
219 
220  void setHasNosplitStack(bool b) {
221  HasNosplitStack = b;
222  }
223 
224  /// Return the symbol to be used for the specified basic block when its
225  /// address is taken. This cannot be its normal LBB label because the block
226  /// may be accessed outside its containing function.
228  return getAddrLabelSymbolToEmit(BB).front();
229  }
230 
231  /// Return the symbol to be used for the specified basic block when its
232  /// address is taken. If other blocks were RAUW'd to this one, we may have
233  /// to emit them as well, return the whole set.
234  ArrayRef<MCSymbol *> getAddrLabelSymbolToEmit(const BasicBlock *BB);
235 
236  /// If the specified function has had any references to address-taken blocks
237  /// generated, but the block got deleted, return the symbol now so we can
238  /// emit it. This prevents emitting a reference to a symbol that has no
239  /// definition.
240  void takeDeletedSymbolsForFunction(const Function *F,
241  std::vector<MCSymbol*> &Result);
242 
243  /// \name Exception Handling
244  /// \{
245 
246  /// Set the call site currently being processed.
247  void setCurrentCallSite(unsigned Site) { CurCallSite = Site; }
248 
249  /// Get the call site currently being processed, if any. return zero if
250  /// none.
251  unsigned getCurrentCallSite() { return CurCallSite; }
252 
253  /// Provide the personality function for the exception information.
254  void addPersonality(const Function *Personality);
255 
256  /// Return array of personality functions ever seen.
257  const std::vector<const Function *>& getPersonalities() const {
258  return Personalities;
259  }
260  /// \}
261 }; // End class MachineModuleInfo
262 
264  MachineModuleInfo MMI;
265 
266 public:
267  static char ID; // Pass identification, replacement for typeid
268  explicit MachineModuleInfoWrapperPass(const LLVMTargetMachine *TM = nullptr);
269 
270  // Initialization and Finalization
271  bool doInitialization(Module &) override;
272  bool doFinalization(Module &) override;
273 
274  MachineModuleInfo &getMMI() { return MMI; }
275  const MachineModuleInfo &getMMI() const { return MMI; }
276 };
277 
278 /// An analysis that produces \c MachineInfo for a module.
279 class MachineModuleAnalysis : public AnalysisInfoMixin<MachineModuleAnalysis> {
281  static AnalysisKey Key;
282 
283  const LLVMTargetMachine *TM;
284 
285 public:
286  /// Provide the result type for this analysis pass.
288 
290 
291  /// Run the analysis pass and produce machine module information.
293 };
294 
295 } // end namespace llvm
296 
297 #endif // LLVM_CODEGEN_MACHINEMODULEINFO_H
MachineModuleAnalysis(const LLVMTargetMachine *TM)
LLVMContext & Context
bool hasDebugInfo() const
Returns true if valid debug info is present.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Various leaf nodes.
Definition: ISDOpcodes.h:59
arc branch finalize
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:66
F(f)
void setCurrentCallSite(unsigned Site)
Set the call site currently being processed.
Context object for machine code objects.
Definition: MCContext.h:65
const MachineModuleInfo & getMMI() const
Key
PAL metadata keys.
const MCContext & getContext() const
unsigned getCurrentCallSite()
Get the call site currently being processed, if any.
static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, ArrayRef< StringLiteral > StandardNames)
Initialize the set of available library functions based on the specified target triple.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
PointerIntPair - This class implements a pair of a pointer and small integer.
void setUsesMSVCFloatingPoint(bool b)
MCSymbol * getAddrLabelSymbol(const BasicBlock *BB)
Return the symbol to be used for the specified basic block when its address is taken.
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:390
This class describes a target machine that is implemented with the LLVM target-independent code gener...
Ty & getObjFileInfo()
Keep track of various per-function pieces of information for backends that would like to do so...
ImmutablePass class - This class is used to provide information that does not need to be run...
Definition: Pass.h:255
void setDebugInfoAvailability(bool avail)
const LLVMTargetMachine & getTarget() const
An analysis that produces MachineInfo for a module.
bool usesMSVCFloatingPoint() const
const Module * getModule() const
std::vector< std::pair< MCSymbol *, StubValueTy > > SymbolListTy
const std::vector< const Function * > & getPersonalities() const
Return array of personality functions ever seen.
const Ty & getObjFileInfo() const
A container for analyses that lazily runs them and caches their results.
This header defines various interfaces for pass management in LLVM.
This class can be derived from and used by targets to hold private target-specific information for ea...
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:71
static SymbolListTy getSortedStubs(DenseMap< MCSymbol *, StubValueTy > &)
Return the entries from a DenseMap in a deterministic sorted orer.
This class contains meta information specific to a module.