]>
Commit | Line | Data |
---|---|---|
223e47cc LB |
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/Pass.h" | |
35 | #include "llvm/GlobalValue.h" | |
36 | #include "llvm/Metadata.h" | |
37 | #include "llvm/MC/MachineLocation.h" | |
38 | #include "llvm/MC/MCContext.h" | |
39 | #include "llvm/Support/Dwarf.h" | |
40 | #include "llvm/Support/DebugLoc.h" | |
41 | #include "llvm/Support/ValueHandle.h" | |
42 | #include "llvm/Support/DataTypes.h" | |
43 | #include "llvm/ADT/DenseMap.h" | |
44 | #include "llvm/ADT/PointerIntPair.h" | |
45 | #include "llvm/ADT/SmallPtrSet.h" | |
46 | #include "llvm/ADT/SmallVector.h" | |
47 | ||
48 | namespace llvm { | |
49 | ||
50 | //===----------------------------------------------------------------------===// | |
51 | // Forward declarations. | |
52 | class Constant; | |
53 | class GlobalVariable; | |
54 | class MDNode; | |
55 | class MMIAddrLabelMap; | |
56 | class MachineBasicBlock; | |
57 | class MachineFunction; | |
58 | class Module; | |
59 | class PointerType; | |
60 | class StructType; | |
61 | ||
62 | //===----------------------------------------------------------------------===// | |
63 | /// LandingPadInfo - This structure is used to retain landing pad info for | |
64 | /// the current function. | |
65 | /// | |
66 | struct LandingPadInfo { | |
67 | MachineBasicBlock *LandingPadBlock; // Landing pad block. | |
68 | SmallVector<MCSymbol*, 1> BeginLabels; // Labels prior to invoke. | |
69 | SmallVector<MCSymbol*, 1> EndLabels; // Labels after invoke. | |
70 | MCSymbol *LandingPadLabel; // Label at beginning of landing pad. | |
71 | const Function *Personality; // Personality function. | |
72 | std::vector<int> TypeIds; // List of type ids (filters negative) | |
73 | ||
74 | explicit LandingPadInfo(MachineBasicBlock *MBB) | |
75 | : LandingPadBlock(MBB), LandingPadLabel(0), Personality(0) {} | |
76 | }; | |
77 | ||
78 | //===----------------------------------------------------------------------===// | |
79 | /// MachineModuleInfoImpl - This class can be derived from and used by targets | |
80 | /// to hold private target-specific information for each Module. Objects of | |
81 | /// type are accessed/created with MMI::getInfo and destroyed when the | |
82 | /// MachineModuleInfo is destroyed. | |
83 | /// | |
84 | class MachineModuleInfoImpl { | |
85 | public: | |
86 | typedef PointerIntPair<MCSymbol*, 1, bool> StubValueTy; | |
87 | virtual ~MachineModuleInfoImpl(); | |
88 | typedef std::vector<std::pair<MCSymbol*, StubValueTy> > SymbolListTy; | |
89 | protected: | |
90 | static SymbolListTy GetSortedStubs(const DenseMap<MCSymbol*, StubValueTy>&); | |
91 | }; | |
92 | ||
93 | //===----------------------------------------------------------------------===// | |
94 | /// MachineModuleInfo - This class contains meta information specific to a | |
95 | /// module. Queries can be made by different debugging and exception handling | |
96 | /// schemes and reformated for specific use. | |
97 | /// | |
98 | class MachineModuleInfo : public ImmutablePass { | |
99 | /// Context - This is the MCContext used for the entire code generator. | |
100 | MCContext Context; | |
101 | ||
102 | /// TheModule - This is the LLVM Module being worked on. | |
103 | const Module *TheModule; | |
104 | ||
105 | /// ObjFileMMI - This is the object-file-format-specific implementation of | |
106 | /// MachineModuleInfoImpl, which lets targets accumulate whatever info they | |
107 | /// want. | |
108 | MachineModuleInfoImpl *ObjFileMMI; | |
109 | ||
110 | /// FrameMoves - List of moves done by a function's prolog. Used to construct | |
111 | /// frame maps by debug and exception handling consumers. | |
112 | std::vector<MachineMove> FrameMoves; | |
113 | ||
114 | /// CompactUnwindEncoding - If the target supports it, this is the compact | |
115 | /// unwind encoding. It replaces a function's CIE and FDE. | |
116 | uint32_t CompactUnwindEncoding; | |
117 | ||
118 | /// LandingPads - List of LandingPadInfo describing the landing pad | |
119 | /// information in the current function. | |
120 | std::vector<LandingPadInfo> LandingPads; | |
121 | ||
122 | /// LPadToCallSiteMap - Map a landing pad's EH symbol to the call site | |
123 | /// indexes. | |
124 | DenseMap<MCSymbol*, SmallVector<unsigned, 4> > LPadToCallSiteMap; | |
125 | ||
126 | /// CallSiteMap - Map of invoke call site index values to associated begin | |
127 | /// EH_LABEL for the current function. | |
128 | DenseMap<MCSymbol*, unsigned> CallSiteMap; | |
129 | ||
130 | /// CurCallSite - The current call site index being processed, if any. 0 if | |
131 | /// none. | |
132 | unsigned CurCallSite; | |
133 | ||
134 | /// TypeInfos - List of C++ TypeInfo used in the current function. | |
135 | std::vector<const GlobalVariable *> TypeInfos; | |
136 | ||
137 | /// FilterIds - List of typeids encoding filters used in the current function. | |
138 | std::vector<unsigned> FilterIds; | |
139 | ||
140 | /// FilterEnds - List of the indices in FilterIds corresponding to filter | |
141 | /// terminators. | |
142 | std::vector<unsigned> FilterEnds; | |
143 | ||
144 | /// Personalities - Vector of all personality functions ever seen. Used to | |
145 | /// emit common EH frames. | |
146 | std::vector<const Function *> Personalities; | |
147 | ||
148 | /// UsedFunctions - The functions in the @llvm.used list in a more easily | |
149 | /// searchable format. This does not include the functions in | |
150 | /// llvm.compiler.used. | |
151 | SmallPtrSet<const Function *, 32> UsedFunctions; | |
152 | ||
153 | /// AddrLabelSymbols - This map keeps track of which symbol is being used for | |
154 | /// the specified basic block's address of label. | |
155 | MMIAddrLabelMap *AddrLabelSymbols; | |
156 | ||
157 | bool CallsEHReturn; | |
158 | bool CallsUnwindInit; | |
159 | ||
160 | /// DbgInfoAvailable - True if debugging information is available | |
161 | /// in this module. | |
162 | bool DbgInfoAvailable; | |
163 | ||
164 | /// UsesVAFloatArgument - True if this module calls VarArg function with | |
165 | /// floating-point arguments. This is used to emit an undefined reference | |
166 | /// to _fltused on Windows targets. | |
167 | bool UsesVAFloatArgument; | |
168 | ||
169 | public: | |
170 | static char ID; // Pass identification, replacement for typeid | |
171 | ||
172 | typedef std::pair<unsigned, DebugLoc> UnsignedDebugLocPair; | |
173 | typedef SmallVector<std::pair<TrackingVH<MDNode>, UnsignedDebugLocPair>, 4> | |
174 | VariableDbgInfoMapTy; | |
175 | VariableDbgInfoMapTy VariableDbgInfo; | |
176 | ||
177 | MachineModuleInfo(); // DUMMY CONSTRUCTOR, DO NOT CALL. | |
178 | // Real constructor. | |
179 | MachineModuleInfo(const MCAsmInfo &MAI, const MCRegisterInfo &MRI, | |
180 | const MCObjectFileInfo *MOFI); | |
181 | ~MachineModuleInfo(); | |
182 | ||
183 | bool doInitialization(); | |
184 | bool doFinalization(); | |
185 | ||
186 | /// EndFunction - Discard function meta information. | |
187 | /// | |
188 | void EndFunction(); | |
189 | ||
190 | const MCContext &getContext() const { return Context; } | |
191 | MCContext &getContext() { return Context; } | |
192 | ||
193 | void setModule(const Module *M) { TheModule = M; } | |
194 | const Module *getModule() const { return TheModule; } | |
195 | ||
196 | /// getInfo - Keep track of various per-function pieces of information for | |
197 | /// backends that would like to do so. | |
198 | /// | |
199 | template<typename Ty> | |
200 | Ty &getObjFileInfo() { | |
201 | if (ObjFileMMI == 0) | |
202 | ObjFileMMI = new Ty(*this); | |
203 | return *static_cast<Ty*>(ObjFileMMI); | |
204 | } | |
205 | ||
206 | template<typename Ty> | |
207 | const Ty &getObjFileInfo() const { | |
208 | return const_cast<MachineModuleInfo*>(this)->getObjFileInfo<Ty>(); | |
209 | } | |
210 | ||
211 | /// AnalyzeModule - Scan the module for global debug information. | |
212 | /// | |
213 | void AnalyzeModule(const Module &M); | |
214 | ||
215 | /// hasDebugInfo - Returns true if valid debug info is present. | |
216 | /// | |
217 | bool hasDebugInfo() const { return DbgInfoAvailable; } | |
218 | void setDebugInfoAvailability(bool avail) { DbgInfoAvailable = avail; } | |
219 | ||
220 | bool callsEHReturn() const { return CallsEHReturn; } | |
221 | void setCallsEHReturn(bool b) { CallsEHReturn = b; } | |
222 | ||
223 | bool callsUnwindInit() const { return CallsUnwindInit; } | |
224 | void setCallsUnwindInit(bool b) { CallsUnwindInit = b; } | |
225 | ||
226 | bool usesVAFloatArgument() const { | |
227 | return UsesVAFloatArgument; | |
228 | } | |
229 | ||
230 | void setUsesVAFloatArgument(bool b) { | |
231 | UsesVAFloatArgument = b; | |
232 | } | |
233 | ||
234 | /// getFrameMoves - Returns a reference to a list of moves done in the current | |
235 | /// function's prologue. Used to construct frame maps for debug and exception | |
236 | /// handling comsumers. | |
237 | std::vector<MachineMove> &getFrameMoves() { return FrameMoves; } | |
238 | ||
239 | /// getCompactUnwindEncoding - Returns the compact unwind encoding for a | |
240 | /// function if the target supports the encoding. This encoding replaces a | |
241 | /// function's CIE and FDE. | |
242 | uint32_t getCompactUnwindEncoding() const { return CompactUnwindEncoding; } | |
243 | ||
244 | /// setCompactUnwindEncoding - Set the compact unwind encoding for a function | |
245 | /// if the target supports the encoding. | |
246 | void setCompactUnwindEncoding(uint32_t Enc) { CompactUnwindEncoding = Enc; } | |
247 | ||
248 | /// getAddrLabelSymbol - Return the symbol to be used for the specified basic | |
249 | /// block when its address is taken. This cannot be its normal LBB label | |
250 | /// because the block may be accessed outside its containing function. | |
251 | MCSymbol *getAddrLabelSymbol(const BasicBlock *BB); | |
252 | ||
253 | /// getAddrLabelSymbolToEmit - Return the symbol to be used for the specified | |
254 | /// basic block when its address is taken. If other blocks were RAUW'd to | |
255 | /// this one, we may have to emit them as well, return the whole set. | |
256 | std::vector<MCSymbol*> getAddrLabelSymbolToEmit(const BasicBlock *BB); | |
257 | ||
258 | /// takeDeletedSymbolsForFunction - If the specified function has had any | |
259 | /// references to address-taken blocks generated, but the block got deleted, | |
260 | /// return the symbol now so we can emit it. This prevents emitting a | |
261 | /// reference to a symbol that has no definition. | |
262 | void takeDeletedSymbolsForFunction(const Function *F, | |
263 | std::vector<MCSymbol*> &Result); | |
264 | ||
265 | ||
266 | //===- EH ---------------------------------------------------------------===// | |
267 | ||
268 | /// getOrCreateLandingPadInfo - Find or create an LandingPadInfo for the | |
269 | /// specified MachineBasicBlock. | |
270 | LandingPadInfo &getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad); | |
271 | ||
272 | /// addInvoke - Provide the begin and end labels of an invoke style call and | |
273 | /// associate it with a try landing pad block. | |
274 | void addInvoke(MachineBasicBlock *LandingPad, | |
275 | MCSymbol *BeginLabel, MCSymbol *EndLabel); | |
276 | ||
277 | /// addLandingPad - Add a new panding pad. Returns the label ID for the | |
278 | /// landing pad entry. | |
279 | MCSymbol *addLandingPad(MachineBasicBlock *LandingPad); | |
280 | ||
281 | /// addPersonality - Provide the personality function for the exception | |
282 | /// information. | |
283 | void addPersonality(MachineBasicBlock *LandingPad, | |
284 | const Function *Personality); | |
285 | ||
286 | /// getPersonalityIndex - Get index of the current personality function inside | |
287 | /// Personalitites array | |
288 | unsigned getPersonalityIndex() const; | |
289 | ||
290 | /// getPersonalities - Return array of personality functions ever seen. | |
291 | const std::vector<const Function *>& getPersonalities() const { | |
292 | return Personalities; | |
293 | } | |
294 | ||
295 | /// isUsedFunction - Return true if the functions in the llvm.used list. This | |
296 | /// does not return true for things in llvm.compiler.used unless they are also | |
297 | /// in llvm.used. | |
298 | bool isUsedFunction(const Function *F) { | |
299 | return UsedFunctions.count(F); | |
300 | } | |
301 | ||
302 | /// addCatchTypeInfo - Provide the catch typeinfo for a landing pad. | |
303 | /// | |
304 | void addCatchTypeInfo(MachineBasicBlock *LandingPad, | |
305 | ArrayRef<const GlobalVariable *> TyInfo); | |
306 | ||
307 | /// addFilterTypeInfo - Provide the filter typeinfo for a landing pad. | |
308 | /// | |
309 | void addFilterTypeInfo(MachineBasicBlock *LandingPad, | |
310 | ArrayRef<const GlobalVariable *> TyInfo); | |
311 | ||
312 | /// addCleanup - Add a cleanup action for a landing pad. | |
313 | /// | |
314 | void addCleanup(MachineBasicBlock *LandingPad); | |
315 | ||
316 | /// getTypeIDFor - Return the type id for the specified typeinfo. This is | |
317 | /// function wide. | |
318 | unsigned getTypeIDFor(const GlobalVariable *TI); | |
319 | ||
320 | /// getFilterIDFor - Return the id of the filter encoded by TyIds. This is | |
321 | /// function wide. | |
322 | int getFilterIDFor(std::vector<unsigned> &TyIds); | |
323 | ||
324 | /// TidyLandingPads - Remap landing pad labels and remove any deleted landing | |
325 | /// pads. | |
326 | void TidyLandingPads(DenseMap<MCSymbol*, uintptr_t> *LPMap = 0); | |
327 | ||
328 | /// getLandingPads - Return a reference to the landing pad info for the | |
329 | /// current function. | |
330 | const std::vector<LandingPadInfo> &getLandingPads() const { | |
331 | return LandingPads; | |
332 | } | |
333 | ||
334 | /// setCallSiteLandingPad - Map the landing pad's EH symbol to the call | |
335 | /// site indexes. | |
336 | void setCallSiteLandingPad(MCSymbol *Sym, ArrayRef<unsigned> Sites); | |
337 | ||
338 | /// getCallSiteLandingPad - Get the call site indexes for a landing pad EH | |
339 | /// symbol. | |
340 | SmallVectorImpl<unsigned> &getCallSiteLandingPad(MCSymbol *Sym) { | |
341 | assert(hasCallSiteLandingPad(Sym) && | |
342 | "missing call site number for landing pad!"); | |
343 | return LPadToCallSiteMap[Sym]; | |
344 | } | |
345 | ||
346 | /// hasCallSiteLandingPad - Return true if the landing pad Eh symbol has an | |
347 | /// associated call site. | |
348 | bool hasCallSiteLandingPad(MCSymbol *Sym) { | |
349 | return !LPadToCallSiteMap[Sym].empty(); | |
350 | } | |
351 | ||
352 | /// setCallSiteBeginLabel - Map the begin label for a call site. | |
353 | void setCallSiteBeginLabel(MCSymbol *BeginLabel, unsigned Site) { | |
354 | CallSiteMap[BeginLabel] = Site; | |
355 | } | |
356 | ||
357 | /// getCallSiteBeginLabel - Get the call site number for a begin label. | |
358 | unsigned getCallSiteBeginLabel(MCSymbol *BeginLabel) { | |
359 | assert(hasCallSiteBeginLabel(BeginLabel) && | |
360 | "Missing call site number for EH_LABEL!"); | |
361 | return CallSiteMap[BeginLabel]; | |
362 | } | |
363 | ||
364 | /// hasCallSiteBeginLabel - Return true if the begin label has a call site | |
365 | /// number associated with it. | |
366 | bool hasCallSiteBeginLabel(MCSymbol *BeginLabel) { | |
367 | return CallSiteMap[BeginLabel] != 0; | |
368 | } | |
369 | ||
370 | /// setCurrentCallSite - Set the call site currently being processed. | |
371 | void setCurrentCallSite(unsigned Site) { CurCallSite = Site; } | |
372 | ||
373 | /// getCurrentCallSite - Get the call site currently being processed, if any. | |
374 | /// return zero if none. | |
375 | unsigned getCurrentCallSite(void) { return CurCallSite; } | |
376 | ||
377 | /// getTypeInfos - Return a reference to the C++ typeinfo for the current | |
378 | /// function. | |
379 | const std::vector<const GlobalVariable *> &getTypeInfos() const { | |
380 | return TypeInfos; | |
381 | } | |
382 | ||
383 | /// getFilterIds - Return a reference to the typeids encoding filters used in | |
384 | /// the current function. | |
385 | const std::vector<unsigned> &getFilterIds() const { | |
386 | return FilterIds; | |
387 | } | |
388 | ||
389 | /// getPersonality - Return a personality function if available. The presence | |
390 | /// of one is required to emit exception handling info. | |
391 | const Function *getPersonality() const; | |
392 | ||
393 | /// setVariableDbgInfo - Collect information used to emit debugging | |
394 | /// information of a variable. | |
395 | void setVariableDbgInfo(MDNode *N, unsigned Slot, DebugLoc Loc) { | |
396 | VariableDbgInfo.push_back(std::make_pair(N, std::make_pair(Slot, Loc))); | |
397 | } | |
398 | ||
399 | VariableDbgInfoMapTy &getVariableDbgInfo() { return VariableDbgInfo; } | |
400 | ||
401 | }; // End class MachineModuleInfo | |
402 | ||
403 | } // End llvm namespace | |
404 | ||
405 | #endif |