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
44namespace llvm {
45
46class BasicBlock;
47class CallInst;
48class Function;
49class MachineFunction;
50class MMIAddrLabelMap;
51class Module;
52class 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///
60class MachineModuleInfoImpl {
61public:
62  using StubValueTy = PointerIntPair<MCSymbol *, 1, bool>;
63  using SymbolListTy = std::vector<std::pair<MCSymbol *, StubValueTy>>;
64
65  virtual ~MachineModuleInfoImpl();
66
67protected:
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///
78class 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
145public:
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  void setModule(const Module *M) { TheModule = M; }
159  const Module *getModule() const { return TheModule; }
160
161  /// Returns the MachineFunction constructed for the IR function \p F.
162  /// Creates a new MachineFunction if none exists yet.
163  MachineFunction &getOrCreateMachineFunction(const Function &F);
164
165  /// \bried Returns the MachineFunction associated to IR function \p F if there
166  /// is one, otherwise nullptr.
167  MachineFunction *getMachineFunction(const Function &F) const;
168
169  /// Delete the MachineFunction \p MF and reset the link in the IR Function to
170  /// Machine Function map.
171  void deleteMachineFunctionFor(Function &F);
172
173  /// Keep track of various per-function pieces of information for backends
174  /// that would like to do so.
175  template<typename Ty>
176  Ty &getObjFileInfo() {
177    if (ObjFileMMI == nullptr)
178      ObjFileMMI = new Ty(*this);
179    return *static_cast<Ty*>(ObjFileMMI);
180  }
181
182  template<typename Ty>
183  const Ty &getObjFileInfo() const {
184    return const_cast<MachineModuleInfo*>(this)->getObjFileInfo<Ty>();
185  }
186
187  /// Returns true if valid debug info is present.
188  bool hasDebugInfo() const { return DbgInfoAvailable; }
189  void setDebugInfoAvailability(bool avail) { DbgInfoAvailable = avail; }
190
191  bool usesVAFloatArgument() const {
192    return UsesVAFloatArgument;
193  }
194
195  void setUsesVAFloatArgument(bool b) {
196    UsesVAFloatArgument = b;
197  }
198
199  bool usesMorestackAddr() const {
200    return UsesMorestackAddr;
201  }
202
203  void setUsesMorestackAddr(bool b) {
204    UsesMorestackAddr = b;
205  }
206
207  bool hasSplitStack() const {
208    return HasSplitStack;
209  }
210
211  void setHasSplitStack(bool b) {
212    HasSplitStack = b;
213  }
214
215  bool hasNosplitStack() const {
216    return HasNosplitStack;
217  }
218
219  void setHasNosplitStack(bool b) {
220    HasNosplitStack = b;
221  }
222
223  /// Return the symbol to be used for the specified basic block when its
224  /// address is taken.  This cannot be its normal LBB label because the block
225  /// may be accessed outside its containing function.
226  MCSymbol *getAddrLabelSymbol(const BasicBlock *BB) {
227    return getAddrLabelSymbolToEmit(BB).front();
228  }
229
230  /// Return the symbol to be used for the specified basic block when its
231  /// address is taken.  If other blocks were RAUW'd to this one, we may have
232  /// to emit them as well, return the whole set.
233  ArrayRef<MCSymbol *> getAddrLabelSymbolToEmit(const BasicBlock *BB);
234
235  /// If the specified function has had any references to address-taken blocks
236  /// generated, but the block got deleted, return the symbol now so we can
237  /// emit it.  This prevents emitting a reference to a symbol that has no
238  /// definition.
239  void takeDeletedSymbolsForFunction(const Function *F,
240                                     std::vector<MCSymbol*> &Result);
241
242  /// \name Exception Handling
243  /// \{
244
245  /// Set the call site currently being processed.
246  void setCurrentCallSite(unsigned Site) { CurCallSite = Site; }
247
248  /// Get the call site currently being processed, if any.  return zero if
249  /// none.
250  unsigned getCurrentCallSite() { return CurCallSite; }
251
252  /// Provide the personality function for the exception information.
253  void addPersonality(const Function *Personality);
254
255  /// Return array of personality functions ever seen.
256  const std::vector<const Function *>& getPersonalities() const {
257    return Personalities;
258  }
259  /// \}
260}; // End class MachineModuleInfo
261
262//===- MMI building helpers -----------------------------------------------===//
263
264/// Determine if any floating-point values are being passed to this variadic
265/// function, and set the MachineModuleInfo's usesVAFloatArgument flag if so.
266/// This flag is used to emit an undefined reference to _fltused on Windows,
267/// which will link in MSVCRT's floating-point support.
268void computeUsesVAFloatArgument(const CallInst &I, MachineModuleInfo &MMI);
269
270} // end namespace llvm
271
272#endif // LLVM_CODEGEN_MACHINEMODULEINFO_H
273