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  /// Maps IR Functions to their corresponding MachineFunctions.
129  DenseMap<const Function*, std::unique_ptr<MachineFunction>> MachineFunctions;
130  /// Next unique number available for a MachineFunction.
131  unsigned NextFnNum = 0;
132  const Function *LastRequest = nullptr; ///< Used for shortcut/cache.
133  MachineFunction *LastResult = nullptr; ///< Used for shortcut/cache.
134
135public:
136  static char ID; // Pass identification, replacement for typeid
137
138  explicit MachineModuleInfo(const TargetMachine *TM = nullptr);
139  ~MachineModuleInfo() override;
140
141  // Initialization and Finalization
142  bool doInitialization(Module &) override;
143  bool doFinalization(Module &) override;
144
145  const MCContext &getContext() const { return Context; }
146  MCContext &getContext() { return Context; }
147
148  void setModule(const Module *M) { TheModule = M; }
149  const Module *getModule() const { return TheModule; }
150
151  /// Returns the MachineFunction constructed for the IR function \p F.
152  /// Creates a new MachineFunction if none exists yet.
153  MachineFunction &getOrCreateMachineFunction(const Function &F);
154
155  /// \bried Returns the MachineFunction associated to IR function \p F if there
156  /// is one, otherwise nullptr.
157  MachineFunction *getMachineFunction(const Function &F) const;
158
159  /// Delete the MachineFunction \p MF and reset the link in the IR Function to
160  /// Machine Function map.
161  void deleteMachineFunctionFor(Function &F);
162
163  /// Keep track of various per-function pieces of information for backends
164  /// that would like to do so.
165  template<typename Ty>
166  Ty &getObjFileInfo() {
167    if (ObjFileMMI == nullptr)
168      ObjFileMMI = new Ty(*this);
169    return *static_cast<Ty*>(ObjFileMMI);
170  }
171
172  template<typename Ty>
173  const Ty &getObjFileInfo() const {
174    return const_cast<MachineModuleInfo*>(this)->getObjFileInfo<Ty>();
175  }
176
177  /// Returns true if valid debug info is present.
178  bool hasDebugInfo() const { return DbgInfoAvailable; }
179  void setDebugInfoAvailability(bool avail) { DbgInfoAvailable = avail; }
180
181  bool usesVAFloatArgument() const {
182    return UsesVAFloatArgument;
183  }
184
185  void setUsesVAFloatArgument(bool b) {
186    UsesVAFloatArgument = b;
187  }
188
189  bool usesMorestackAddr() const {
190    return UsesMorestackAddr;
191  }
192
193  void setUsesMorestackAddr(bool b) {
194    UsesMorestackAddr = b;
195  }
196
197  /// Return the symbol to be used for the specified basic block when its
198  /// address is taken.  This cannot be its normal LBB label because the block
199  /// may be accessed outside its containing function.
200  MCSymbol *getAddrLabelSymbol(const BasicBlock *BB) {
201    return getAddrLabelSymbolToEmit(BB).front();
202  }
203
204  /// Return the symbol to be used for the specified basic block when its
205  /// address is taken.  If other blocks were RAUW'd to this one, we may have
206  /// to emit them as well, return the whole set.
207  ArrayRef<MCSymbol *> getAddrLabelSymbolToEmit(const BasicBlock *BB);
208
209  /// If the specified function has had any references to address-taken blocks
210  /// generated, but the block got deleted, return the symbol now so we can
211  /// emit it.  This prevents emitting a reference to a symbol that has no
212  /// definition.
213  void takeDeletedSymbolsForFunction(const Function *F,
214                                     std::vector<MCSymbol*> &Result);
215
216  /// \name Exception Handling
217  /// \{
218
219  /// Set the call site currently being processed.
220  void setCurrentCallSite(unsigned Site) { CurCallSite = Site; }
221
222  /// Get the call site currently being processed, if any.  return zero if
223  /// none.
224  unsigned getCurrentCallSite() { return CurCallSite; }
225
226  /// Provide the personality function for the exception information.
227  void addPersonality(const Function *Personality);
228
229  /// Return array of personality functions ever seen.
230  const std::vector<const Function *>& getPersonalities() const {
231    return Personalities;
232  }
233  /// \}
234}; // End class MachineModuleInfo
235
236//===- MMI building helpers -----------------------------------------------===//
237
238/// Determine if any floating-point values are being passed to this variadic
239/// function, and set the MachineModuleInfo's usesVAFloatArgument flag if so.
240/// This flag is used to emit an undefined reference to _fltused on Windows,
241/// which will link in MSVCRT's floating-point support.
242void computeUsesVAFloatArgument(const CallInst &I, MachineModuleInfo &MMI);
243
244} // end namespace llvm
245
246#endif // LLVM_CODEGEN_MACHINEMODULEINFO_H
247