LLVM  4.0.0
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/DebugLoc.h"
39 #include "llvm/IR/ValueHandle.h"
40 #include "llvm/MC/MCContext.h"
41 #include "llvm/MC/MCSymbol.h"
43 #include "llvm/Pass.h"
44 #include "llvm/Support/DataTypes.h"
45 
46 namespace llvm {
47 
48 //===----------------------------------------------------------------------===//
49 // Forward declarations.
50 class BlockAddress;
51 class CallInst;
52 class Constant;
53 class GlobalVariable;
54 class LandingPadInst;
55 class MDNode;
56 class MMIAddrLabelMap;
57 class MachineBasicBlock;
58 class MachineFunction;
59 class MachineFunctionInitializer;
60 class Module;
61 class PointerType;
62 class StructType;
63 
64 //===----------------------------------------------------------------------===//
65 /// This class can be derived from and used by targets to hold private
66 /// target-specific information for each Module. Objects of type are
67 /// accessed/created with MMI::getInfo and destroyed when the MachineModuleInfo
68 /// is destroyed.
69 ///
71 public:
73  virtual ~MachineModuleInfoImpl();
74  typedef std::vector<std::pair<MCSymbol*, StubValueTy> > SymbolListTy;
75 protected:
76 
77  /// Return the entries from a DenseMap in a deterministic sorted orer.
78  /// Clears the map.
80 };
81 
82 //===----------------------------------------------------------------------===//
83 /// This class contains meta information specific to a module. Queries can be
84 /// made by different debugging and exception handling schemes and reformated
85 /// for specific use.
86 ///
88  const TargetMachine &TM;
89 
90  /// This is the MCContext used for the entire code generator.
91  MCContext Context;
92 
93  /// This is the LLVM Module being worked on.
94  const Module *TheModule;
95 
96  /// This is the object-file-format-specific implementation of
97  /// MachineModuleInfoImpl, which lets targets accumulate whatever info they
98  /// want.
99  MachineModuleInfoImpl *ObjFileMMI;
100 
101  /// \name Exception Handling
102  /// \{
103 
104  /// Vector of all personality functions ever seen. Used to emit common EH
105  /// frames.
106  std::vector<const Function *> Personalities;
107 
108  /// The current call site index being processed, if any. 0 if none.
109  unsigned CurCallSite;
110 
111  /// \}
112 
113  /// This map keeps track of which symbol is being used for the specified
114  /// basic block's address of label.
115  MMIAddrLabelMap *AddrLabelSymbols;
116 
117  // TODO: Ideally, what we'd like is to have a switch that allows emitting
118  // synchronous (precise at call-sites only) CFA into .eh_frame. However,
119  // even under this switch, we'd like .debug_frame to be precise when using.
120  // -g. At this moment, there's no way to specify that some CFI directives
121  // go into .eh_frame only, while others go into .debug_frame only.
122 
123  /// True if debugging information is available in this module.
124  bool DbgInfoAvailable;
125 
126  /// True if this module calls VarArg function with floating-point arguments.
127  /// This is used to emit an undefined reference to _fltused on Windows
128  /// targets.
129  bool UsesVAFloatArgument;
130 
131  /// True if the module calls the __morestack function indirectly, as is
132  /// required under the large code model on x86. This is used to emit
133  /// a definition of a symbol, __morestack_addr, containing the address. See
134  /// comments in lib/Target/X86/X86FrameLowering.cpp for more details.
135  bool UsesMorestackAddr;
136 
137  MachineFunctionInitializer *MFInitializer;
138  /// Maps IR Functions to their corresponding 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  MCContext &getContext() { return Context; }
157 
158  void setModule(const Module *M) { TheModule = M; }
159  const Module *getModule() const { return TheModule; }
160 
162  MFInitializer = MFInit;
163  }
164 
165  /// Returns the MachineFunction constructed for the IR function \p F.
166  /// Creates a new MachineFunction and runs the MachineFunctionInitializer
167  /// if none exists yet.
169 
170  /// Delete the MachineFunction \p MF and reset the link in the IR Function to
171  /// Machine Function map.
173 
174  /// Keep track of various per-function pieces of information for backends
175  /// that would like to do so.
176  template<typename Ty>
178  if (ObjFileMMI == nullptr)
179  ObjFileMMI = new Ty(*this);
180  return *static_cast<Ty*>(ObjFileMMI);
181  }
182 
183  template<typename Ty>
184  const Ty &getObjFileInfo() const {
185  return const_cast<MachineModuleInfo*>(this)->getObjFileInfo<Ty>();
186  }
187 
188  /// Returns true if valid debug info is present.
189  bool hasDebugInfo() const { return DbgInfoAvailable; }
190  void setDebugInfoAvailability(bool avail) { DbgInfoAvailable = avail; }
191 
192  bool usesVAFloatArgument() const {
193  return UsesVAFloatArgument;
194  }
195 
196  void setUsesVAFloatArgument(bool b) {
197  UsesVAFloatArgument = b;
198  }
199 
200  bool usesMorestackAddr() const {
201  return UsesMorestackAddr;
202  }
203 
204  void setUsesMorestackAddr(bool b) {
205  UsesMorestackAddr = b;
206  }
207 
208  /// Return the symbol to be used for the specified basic block when its
209  /// address is taken. This cannot be its normal LBB label because the block
210  /// may be accessed outside its containing function.
212  return getAddrLabelSymbolToEmit(BB).front();
213  }
214 
215  /// Return the symbol to be used for the specified basic block when its
216  /// address is taken. If other blocks were RAUW'd to this one, we may have
217  /// to emit them as well, return the whole set.
219 
220  /// If the specified function has had any references to address-taken blocks
221  /// generated, but the block got deleted, return the symbol now so we can
222  /// emit it. This prevents emitting a reference to a symbol that has no
223  /// definition.
225  std::vector<MCSymbol*> &Result);
226 
227  /// \name Exception Handling
228  /// \{
229 
230  /// Set the call site currently being processed.
231  void setCurrentCallSite(unsigned Site) { CurCallSite = Site; }
232 
233  /// Get the call site currently being processed, if any. return zero if
234  /// none.
235  unsigned getCurrentCallSite() { return CurCallSite; }
236 
237  /// Provide the personality function for the exception information.
238  void addPersonality(const Function *Personality);
239 
240  /// Return array of personality functions ever seen.
241  const std::vector<const Function *>& getPersonalities() const {
242  return Personalities;
243  }
244  /// \}
245 }; // End class MachineModuleInfo
246 
247 //===- MMI building helpers -----------------------------------------------===//
248 
249 /// Determine if any floating-point values are being passed to this variadic
250 /// function, and set the MachineModuleInfo's usesVAFloatArgument flag if so.
251 /// This flag is used to emit an undefined reference to _fltused on Windows,
252 /// which will link in MSVCRT's floating-point support.
253 void computeUsesVAFloatArgument(const CallInst &I, MachineModuleInfo &MMI);
254 
255 } // End llvm namespace
256 
257 #endif
const Ty & getObjFileInfo() const
PointerIntPair< MCSymbol *, 1, bool > StubValueTy
bool doFinalization(Module &) override
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:39
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
void deleteMachineFunctionFor(Function &F)
Delete the MachineFunction MF and reset the link in the IR Function to Machine Function map...
std::vector< std::pair< MCSymbol *, StubValueTy > > SymbolListTy
void computeUsesVAFloatArgument(const CallInst &I, MachineModuleInfo &MMI)
Determine if any floating-point values are being passed to this variadic function, and set the MachineModuleInfo's usesVAFloatArgument flag if so.
void setCurrentCallSite(unsigned Site)
Set the call site currently being processed.
void takeDeletedSymbolsForFunction(const Function *F, std::vector< MCSymbol * > &Result)
If the specified function has had any references to address-taken blocks generated, but the block got deleted, return the symbol now so we can emit it.
const Module * getModule() const
MachineModuleInfo(const TargetMachine *TM=nullptr)
bool hasDebugInfo() const
Returns true if valid debug info is present.
bool usesVAFloatArgument() const
Context object for machine code objects.
Definition: MCContext.h:51
#define F(x, y, z)
Definition: MD5.cpp:51
unsigned getCurrentCallSite()
Get the call site currently being processed, if any.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
ArrayRef< MCSymbol * > getAddrLabelSymbolToEmit(const BasicBlock *BB)
Return the symbol to be used for the specified basic block when its address is taken.
MachineFunction & getMachineFunction(const Function &F)
Returns the MachineFunction constructed for the IR function F.
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
PointerIntPair - This class implements a pair of a pointer and small integer.
void addPersonality(const Function *Personality)
Provide the personality function for the exception information.
MCSymbol * getAddrLabelSymbol(const BasicBlock *BB)
Return the symbol to be used for the specified basic block when its address is taken.
const std::vector< const Function * > & getPersonalities() const
Return array of personality functions ever seen.
Ty & getObjFileInfo()
Keep track of various per-function pieces of information for backends that would like to do so...
void setMachineFunctionInitializer(MachineFunctionInitializer *MFInit)
ImmutablePass class - This class is used to provide information that does not need to be run...
Definition: Pass.h:266
void setDebugInfoAvailability(bool avail)
const MCContext & getContext() const
bool doInitialization(Module &) override
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...
void setModule(const Module *M)
#define I(x, y, z)
Definition: MD5.cpp:54
void setUsesVAFloatArgument(bool b)
Primary interface to the complete machine description for the target machine.
This interface provides a way to initialize machine functions after they are created by the machine f...
This class can be derived from and used by targets to hold private target-specific information for ea...
static SymbolListTy getSortedStubs(DenseMap< MCSymbol *, StubValueTy > &)
Return the entries from a DenseMap in a deterministic sorted orer.
This class contains meta information specific to a module.