Line data Source code
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 26527 : 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 85236 : 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 1868572 : MCContext &getContext() { return Context; }
157 :
158 0 : 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 19828 : Ty &getObjFileInfo() {
176 19828 : if (ObjFileMMI == nullptr)
177 1921 : ObjFileMMI = new Ty(*this);
178 19828 : return *static_cast<Ty*>(ObjFileMMI);
179 : }
180 0 :
181 0 : template<typename Ty>
182 0 : const Ty &getObjFileInfo() const {
183 0 : return const_cast<MachineModuleInfo*>(this)->getObjFileInfo<Ty>();
184 : }
185 0 :
186 0 : /// Returns true if valid debug info is present.
187 0 : bool hasDebugInfo() const { return DbgInfoAvailable; }
188 27113 : void setDebugInfoAvailability(bool avail) { DbgInfoAvailable = avail; }
189 :
190 0 : bool usesVAFloatArgument() const {
191 0 : return UsesVAFloatArgument;
192 : }
193 :
194 : void setUsesVAFloatArgument(bool b) {
195 140 : UsesVAFloatArgument = b;
196 : }
197 0 :
198 : bool usesMorestackAddr() const {
199 : return UsesMorestackAddr;
200 : }
201 :
202 : void setUsesMorestackAddr(bool b) {
203 7 : UsesMorestackAddr = b;
204 : }
205 :
206 : bool hasSplitStack() const {
207 : return HasSplitStack;
208 0 : }
209 0 :
210 : void setHasSplitStack(bool b) {
211 239 : HasSplitStack = b;
212 : }
213 :
214 : bool hasNosplitStack() const {
215 : return HasNosplitStack;
216 0 : }
217 0 :
218 : void setHasNosplitStack(bool b) {
219 404064 : 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 0 : /// may be accessed outside its containing function.
225 0 : 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 1138 : /// 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 350 : void setCurrentCallSite(unsigned Site) { CurCallSite = Site; }
246 :
247 : /// Get the call site currently being processed, if any. return zero if
248 : /// none.
249 0 : 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
|
