LLVM API Documentation

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