LLVM  6.0.0svn
LLVMContext.h
Go to the documentation of this file.
1 //===- llvm/LLVMContext.h - Class for managing "global" state ---*- 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 // This file declares LLVMContext, a container of "global" state in LLVM, such
11 // as the global type and constant uniquing tables.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_IR_LLVMCONTEXT_H
16 #define LLVM_IR_LLVMCONTEXT_H
17 
18 #include "llvm-c/Types.h"
20 #include "llvm/Support/Options.h"
21 #include <cstdint>
22 #include <memory>
23 #include <string>
24 
25 namespace llvm {
26 
27 class DiagnosticInfo;
29 class Function;
30 class Instruction;
31 class LLVMContextImpl;
32 class Module;
33 class OptBisect;
34 template <typename T> class SmallVectorImpl;
35 class SMDiagnostic;
36 class StringRef;
37 class Twine;
38 
39 namespace yaml {
40 
41 class Output;
42 
43 } // end namespace yaml
44 
45 namespace SyncScope {
46 
47 typedef uint8_t ID;
48 
49 /// Known synchronization scope IDs, which always have the same value. All
50 /// synchronization scope IDs that LLVM has special knowledge of are listed
51 /// here. Additionally, this scheme allows LLVM to efficiently check for
52 /// specific synchronization scope ID without comparing strings.
53 enum {
54  /// Synchronized with respect to signal handlers executing in the same thread.
56 
57  /// Synchronized with respect to all concurrently executing threads.
58  System = 1
59 };
60 
61 } // end namespace SyncScope
62 
63 /// This is an important class for using LLVM in a threaded context. It
64 /// (opaquely) owns and manages the core "global" data of LLVM's core
65 /// infrastructure, including the type and constant uniquing tables.
66 /// LLVMContext itself provides no locking guarantees, so you should be careful
67 /// to have one context per thread.
68 class LLVMContext {
69 public:
71  LLVMContext();
72  LLVMContext(LLVMContext &) = delete;
73  LLVMContext &operator=(const LLVMContext &) = delete;
74  ~LLVMContext();
75 
76  // Pinned metadata names, which always have the same value. This is a
77  // compile-time performance optimization, not a correctness optimization.
78  enum {
79  MD_dbg = 0, // "dbg"
80  MD_tbaa = 1, // "tbaa"
81  MD_prof = 2, // "prof"
82  MD_fpmath = 3, // "fpmath"
83  MD_range = 4, // "range"
84  MD_tbaa_struct = 5, // "tbaa.struct"
85  MD_invariant_load = 6, // "invariant.load"
86  MD_alias_scope = 7, // "alias.scope"
87  MD_noalias = 8, // "noalias",
88  MD_nontemporal = 9, // "nontemporal"
89  MD_mem_parallel_loop_access = 10, // "llvm.mem.parallel_loop_access"
90  MD_nonnull = 11, // "nonnull"
91  MD_dereferenceable = 12, // "dereferenceable"
92  MD_dereferenceable_or_null = 13, // "dereferenceable_or_null"
93  MD_make_implicit = 14, // "make.implicit"
94  MD_unpredictable = 15, // "unpredictable"
95  MD_invariant_group = 16, // "invariant.group"
96  MD_align = 17, // "align"
97  MD_loop = 18, // "llvm.loop"
98  MD_type = 19, // "type"
99  MD_section_prefix = 20, // "section_prefix"
100  MD_absolute_symbol = 21, // "absolute_symbol"
101  MD_associated = 22, // "associated"
102  };
103 
104  /// Known operand bundle tag IDs, which always have the same value. All
105  /// operand bundle tags that LLVM has special knowledge of are listed here.
106  /// Additionally, this scheme allows LLVM to efficiently check for specific
107  /// operand bundle tags without comparing strings.
108  enum {
109  OB_deopt = 0, // "deopt"
110  OB_funclet = 1, // "funclet"
111  OB_gc_transition = 2, // "gc-transition"
112  };
113 
114  /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
115  /// This ID is uniqued across modules in the current LLVMContext.
116  unsigned getMDKindID(StringRef Name) const;
117 
118  /// getMDKindNames - Populate client supplied SmallVector with the name for
119  /// custom metadata IDs registered in this LLVMContext.
120  void getMDKindNames(SmallVectorImpl<StringRef> &Result) const;
121 
122  /// getOperandBundleTags - Populate client supplied SmallVector with the
123  /// bundle tags registered in this LLVMContext. The bundle tags are ordered
124  /// by increasing bundle IDs.
125  /// \see LLVMContext::getOperandBundleTagID
126  void getOperandBundleTags(SmallVectorImpl<StringRef> &Result) const;
127 
128  /// getOperandBundleTagID - Maps a bundle tag to an integer ID. Every bundle
129  /// tag registered with an LLVMContext has an unique ID.
130  uint32_t getOperandBundleTagID(StringRef Tag) const;
131 
132  /// getOrInsertSyncScopeID - Maps synchronization scope name to
133  /// synchronization scope ID. Every synchronization scope registered with
134  /// LLVMContext has unique ID except pre-defined ones.
135  SyncScope::ID getOrInsertSyncScopeID(StringRef SSN);
136 
137  /// getSyncScopeNames - Populates client supplied SmallVector with
138  /// synchronization scope names registered with LLVMContext. Synchronization
139  /// scope names are ordered by increasing synchronization scope IDs.
140  void getSyncScopeNames(SmallVectorImpl<StringRef> &SSNs) const;
141 
142  /// Define the GC for a function
143  void setGC(const Function &Fn, std::string GCName);
144 
145  /// Return the GC for a function
146  const std::string &getGC(const Function &Fn);
147 
148  /// Remove the GC for a function
149  void deleteGC(const Function &Fn);
150 
151  /// Return true if the Context runtime configuration is set to discard all
152  /// value names. When true, only GlobalValue names will be available in the
153  /// IR.
154  bool shouldDiscardValueNames() const;
155 
156  /// Set the Context runtime configuration to discard all value name (but
157  /// GlobalValue). Clients can use this flag to save memory and runtime,
158  /// especially in release mode.
159  void setDiscardValueNames(bool Discard);
160 
161  /// Whether there is a string map for uniquing debug info
162  /// identifiers across the context. Off by default.
163  bool isODRUniquingDebugTypes() const;
164  void enableDebugTypeODRUniquing();
165  void disableDebugTypeODRUniquing();
166 
167  using InlineAsmDiagHandlerTy = void (*)(const SMDiagnostic&, void *Context,
168  unsigned LocCookie);
169 
170  /// Defines the type of a diagnostic handler.
171  /// \see LLVMContext::setDiagnosticHandler.
172  /// \see LLVMContext::diagnose.
173  using DiagnosticHandlerTy = void (*)(const DiagnosticInfo &DI, void *Context);
174 
175  /// Defines the type of a yield callback.
176  /// \see LLVMContext::setYieldCallback.
177  using YieldCallbackTy = void (*)(LLVMContext *Context, void *OpaqueHandle);
178 
179  /// setInlineAsmDiagnosticHandler - This method sets a handler that is invoked
180  /// when problems with inline asm are detected by the backend. The first
181  /// argument is a function pointer and the second is a context pointer that
182  /// gets passed into the DiagHandler.
183  ///
184  /// LLVMContext doesn't take ownership or interpret either of these
185  /// pointers.
186  void setInlineAsmDiagnosticHandler(InlineAsmDiagHandlerTy DiagHandler,
187  void *DiagContext = nullptr);
188 
189  /// getInlineAsmDiagnosticHandler - Return the diagnostic handler set by
190  /// setInlineAsmDiagnosticHandler.
191  InlineAsmDiagHandlerTy getInlineAsmDiagnosticHandler() const;
192 
193  /// getInlineAsmDiagnosticContext - Return the diagnostic context set by
194  /// setInlineAsmDiagnosticHandler.
195  void *getInlineAsmDiagnosticContext() const;
196 
197  /// setDiagnosticHandler - This method sets a handler that is invoked
198  /// when the backend needs to report anything to the user. The first
199  /// argument is a function pointer and the second is a context pointer that
200  /// gets passed into the DiagHandler. The third argument should be set to
201  /// true if the handler only expects enabled diagnostics.
202  ///
203  /// LLVMContext doesn't take ownership or interpret either of these
204  /// pointers.
205  void setDiagnosticHandler(DiagnosticHandlerTy DiagHandler,
206  void *DiagContext = nullptr,
207  bool RespectFilters = false);
208 
209  /// getDiagnosticHandler - Return the diagnostic handler set by
210  /// setDiagnosticHandler.
211  DiagnosticHandlerTy getDiagnosticHandler() const;
212 
213  /// getDiagnosticContext - Return the diagnostic context set by
214  /// setDiagnosticContext.
215  void *getDiagnosticContext() const;
216 
217  /// \brief Return if a code hotness metric should be included in optimization
218  /// diagnostics.
219  bool getDiagnosticsHotnessRequested() const;
220  /// \brief Set if a code hotness metric should be included in optimization
221  /// diagnostics.
222  void setDiagnosticsHotnessRequested(bool Requested);
223 
224  /// \brief Return the minimum hotness value a diagnostic would need in order
225  /// to be included in optimization diagnostics. If there is no minimum, this
226  /// returns None.
227  uint64_t getDiagnosticsHotnessThreshold() const;
228 
229  /// \brief Set the minimum hotness value a diagnostic needs in order to be
230  /// included in optimization diagnostics.
231  void setDiagnosticsHotnessThreshold(uint64_t Threshold);
232 
233  /// \brief Return the YAML file used by the backend to save optimization
234  /// diagnostics. If null, diagnostics are not saved in a file but only
235  /// emitted via the diagnostic handler.
236  yaml::Output *getDiagnosticsOutputFile();
237  /// Set the diagnostics output file used for optimization diagnostics.
238  ///
239  /// By default or if invoked with null, diagnostics are not saved in a file
240  /// but only emitted via the diagnostic handler. Even if an output file is
241  /// set, the handler is invoked for each diagnostic message.
242  void setDiagnosticsOutputFile(std::unique_ptr<yaml::Output> F);
243 
244  /// \brief Get the prefix that should be printed in front of a diagnostic of
245  /// the given \p Severity
246  static const char *getDiagnosticMessagePrefix(DiagnosticSeverity Severity);
247 
248  /// \brief Report a message to the currently installed diagnostic handler.
249  ///
250  /// This function returns, in particular in the case of error reporting
251  /// (DI.Severity == \a DS_Error), so the caller should leave the compilation
252  /// process in a self-consistent state, even though the generated code
253  /// need not be correct.
254  ///
255  /// The diagnostic message will be implicitly prefixed with a severity keyword
256  /// according to \p DI.getSeverity(), i.e., "error: " for \a DS_Error,
257  /// "warning: " for \a DS_Warning, and "note: " for \a DS_Note.
258  void diagnose(const DiagnosticInfo &DI);
259 
260  /// \brief Registers a yield callback with the given context.
261  ///
262  /// The yield callback function may be called by LLVM to transfer control back
263  /// to the client that invoked the LLVM compilation. This can be used to yield
264  /// control of the thread, or perform periodic work needed by the client.
265  /// There is no guaranteed frequency at which callbacks must occur; in fact,
266  /// the client is not guaranteed to ever receive this callback. It is at the
267  /// sole discretion of LLVM to do so and only if it can guarantee that
268  /// suspending the thread won't block any forward progress in other LLVM
269  /// contexts in the same process.
270  ///
271  /// At a suspend point, the state of the current LLVM context is intentionally
272  /// undefined. No assumptions about it can or should be made. Only LLVM
273  /// context API calls that explicitly state that they can be used during a
274  /// yield callback are allowed to be used. Any other API calls into the
275  /// context are not supported until the yield callback function returns
276  /// control to LLVM. Other LLVM contexts are unaffected by this restriction.
277  void setYieldCallback(YieldCallbackTy Callback, void *OpaqueHandle);
278 
279  /// \brief Calls the yield callback (if applicable).
280  ///
281  /// This transfers control of the current thread back to the client, which may
282  /// suspend the current thread. Only call this method when LLVM doesn't hold
283  /// any global mutex or cannot block the execution in another LLVM context.
284  void yield();
285 
286  /// emitError - Emit an error message to the currently installed error handler
287  /// with optional location information. This function returns, so code should
288  /// be prepared to drop the erroneous construct on the floor and "not crash".
289  /// The generated code need not be correct. The error message will be
290  /// implicitly prefixed with "error: " and should not end with a ".".
291  void emitError(unsigned LocCookie, const Twine &ErrorStr);
292  void emitError(const Instruction *I, const Twine &ErrorStr);
293  void emitError(const Twine &ErrorStr);
294 
295  /// \brief Query for a debug option's value.
296  ///
297  /// This function returns typed data populated from command line parsing.
298  template <typename ValT, typename Base, ValT(Base::*Mem)>
299  ValT getOption() const {
300  return OptionRegistry::instance().template get<ValT, Base, Mem>();
301  }
302 
303  /// \brief Access the object which manages optimization bisection for failure
304  /// analysis.
305  OptBisect &getOptBisect();
306 private:
307  // Module needs access to the add/removeModule methods.
308  friend class Module;
309 
310  /// addModule - Register a module as being instantiated in this context. If
311  /// the context is deleted, the module will be deleted as well.
312  void addModule(Module*);
313 
314  /// removeModule - Unregister a module from this context.
315  void removeModule(Module*);
316 };
317 
318 // Create wrappers for C Binding types (see CBindingWrapping.h).
320 
321 /* Specialized opaque context conversions.
322  */
324  return reinterpret_cast<LLVMContext**>(Tys);
325 }
326 
327 inline LLVMContextRef *wrap(const LLVMContext **Tys) {
328  return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys));
329 }
330 
331 } // end namespace llvm
332 
333 #endif // LLVM_IR_LLVMCONTEXT_H
LLVMContext & Context
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
void(*)(LLVMContext *Context, void *OpaqueHandle) YieldCallbackTy
Defines the type of a yield callback.
Definition: LLVMContext.h:177
DiagnosticSeverity
Defines the different supported severity of a diagnostic.
#define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:195
#define F(x, y, z)
Definition: MD5.cpp:55
static OptionRegistry & instance()
Returns a reference to the singleton instance.
Definition: Options.cpp:33
struct LLVMOpaqueContext * LLVMContextRef
The top-level container for all LLVM global data.
Definition: Types.h:54
const char * Name
This class implements a mechanism to disable passes and individual optimizations at compile time base...
Definition: OptBisect.h:28
This is the base abstract class for diagnostic reporting in the backend.
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
The Output class is used to generate a yaml document from in-memory structs and vectors.
Definition: YAMLTraits.h:1260
LLVMContextImpl *const pImpl
Definition: LLVMContext.h:70
void(*)(const DiagnosticInfo &DI, void *Context) DiagnosticHandlerTy
Defines the type of a diagnostic handler.
Definition: LLVMContext.h:173
ValT getOption() const
Query for a debug option&#39;s value.
Definition: LLVMContext.h:299
Synchronized with respect to all concurrently executing threads.
Definition: LLVMContext.h:58
This file declares helper objects for defining debug options that can be configured via the command l...
always inline
Synchronized with respect to signal handlers executing in the same thread.
Definition: LLVMContext.h:55
void(*)(const SMDiagnostic &, void *Context, unsigned LocCookie) InlineAsmDiagHandlerTy
Definition: LLVMContext.h:168
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:190
#define I(x, y, z)
Definition: MD5.cpp:58
static int const Threshold
TODO: Write a new FunctionPass AliasAnalysis so that it can keep a cache.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Definition: SourceMgr.h:232