1//===- llvm/LLVMContext.h - Class for managing "global" state ---*- C++ -*-===// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7//===----------------------------------------------------------------------===// 9// This file declares LLVMContext, a container of "global" state in LLVM, such 10// as the global type and constant uniquing tables. 12//===----------------------------------------------------------------------===// 14#ifndef LLVM_IR_LLVMCONTEXT_H 15#define LLVM_IR_LLVMCONTEXT_H 34template <
typename T>
classSmallVectorImpl;
35template <
typename T>
classStringMapEntry;
38classLLVMRemarkStreamer;
48/// Known synchronization scope IDs, which always have the same value. All 49/// synchronization scope IDs that LLVM has special knowledge of are listed 50/// here. Additionally, this scheme allows LLVM to efficiently check for 51/// specific synchronization scope ID without comparing strings. 53 /// Synchronized with respect to signal handlers executing in the same thread. 56 /// Synchronized with respect to all concurrently executing threads. 60}
// end namespace SyncScope 62/// This is an important class for using LLVM in a threaded context. It 63/// (opaquely) owns and manages the core "global" data of LLVM's core 64/// infrastructure, including the type and constant uniquing tables. 65/// LLVMContext itself provides no locking guarantees, so you should be careful 66/// to have one context per thread. 75// Pinned metadata names, which always have the same value. This is a 76// compile-time performance optimization, not a correctness optimization. 78#define LLVM_FIXED_MD_KIND(EnumID, Name, Value) EnumID = Value, 79#include "llvm/IR/FixedMetadataKinds.def" 80#undef LLVM_FIXED_MD_KIND 83 /// Known operand bundle tag IDs, which always have the same value. All 84 /// operand bundle tags that LLVM has special knowledge of are listed here. 85 /// Additionally, this scheme allows LLVM to efficiently check for specific 86 /// operand bundle tags without comparing strings. Keep this in sync with 87 /// LLVMContext::LLVMContext(). 101 /// getMDKindID - Return a unique non-zero ID for the specified metadata kind. 102 /// This ID is uniqued across modules in the current LLVMContext. 105 /// getMDKindNames - Populate client supplied SmallVector with the name for 106 /// custom metadata IDs registered in this LLVMContext. 109 /// getOperandBundleTags - Populate client supplied SmallVector with the 110 /// bundle tags registered in this LLVMContext. The bundle tags are ordered 111 /// by increasing bundle IDs. 112 /// \see LLVMContext::getOperandBundleTagID 115 /// getOrInsertBundleTag - Returns the Tag to use for an operand bundle of 119 /// getOperandBundleTagID - Maps a bundle tag to an integer ID. Every bundle 120 /// tag registered with an LLVMContext has an unique ID. 123 /// getOrInsertSyncScopeID - Maps synchronization scope name to 124 /// synchronization scope ID. Every synchronization scope registered with 125 /// LLVMContext has unique ID except pre-defined ones. 128 /// getSyncScopeNames - Populates client supplied SmallVector with 129 /// synchronization scope names registered with LLVMContext. Synchronization 130 /// scope names are ordered by increasing synchronization scope IDs. 133 /// getSyncScopeName - Returns the name of a SyncScope::ID 134 /// registered with LLVMContext, if any. 137 /// Define the GC for a function 140 /// Return the GC for a function 143 /// Remove the GC for a function 146 /// Return true if the Context runtime configuration is set to discard all 147 /// value names. When true, only GlobalValue names will be available in the 151 /// Set the Context runtime configuration to discard all value name (but 152 /// GlobalValue). Clients can use this flag to save memory and runtime, 153 /// especially in release mode. 156 /// Whether there is a string map for uniquing debug info 157 /// identifiers across the context. Off by default. 162 /// generateMachineFunctionNum - Get a unique number for MachineFunction 163 /// that associated with the given Function. 166 /// Defines the type of a yield callback. 167 /// \see LLVMContext::setYieldCallback. 170 /// setDiagnosticHandlerCallBack - This method sets a handler call back 171 /// that is invoked when the backend needs to report anything to the user. 172 /// The first argument is a function pointer and the second is a context pointer 173 /// that gets passed into the DiagHandler. The third argument should be set to 174 /// true if the handler only expects enabled diagnostics. 176 /// LLVMContext doesn't take ownership or interpret either of these 180void *DiagContext =
nullptr,
bool RespectFilters =
false);
182 /// setDiagnosticHandler - This method sets unique_ptr to object of 183 /// DiagnosticHandler to provide custom diagnostic handling. The first 184 /// argument is unique_ptr of object of type DiagnosticHandler or a derived 185 /// of that. The second argument should be set to true if the handler only 186 /// expects enabled diagnostics. 188 /// Ownership of this pointer is moved to LLVMContextImpl. 190bool RespectFilters =
false);
192 /// getDiagnosticHandlerCallBack - Return the diagnostic handler call back set by 193 /// setDiagnosticHandlerCallBack. 196 /// getDiagnosticContext - Return the diagnostic context set by 197 /// setDiagnosticContext. 200 /// getDiagHandlerPtr - Returns const raw pointer of DiagnosticHandler set by 201 /// setDiagnosticHandler. 204 /// getDiagnosticHandler - transfers ownership of DiagnosticHandler unique_ptr 208 /// Return if a code hotness metric should be included in optimization 211 /// Set if a code hotness metric should be included in optimization 220 /// Return the minimum hotness value a diagnostic would need in order 221 /// to be included in optimization diagnostics. 223 /// Three possible return values: 224 /// 0 - threshold is disabled. Everything will be printed out. 225 /// positive int - threshold is set. 226 /// UINT64_MAX - threshold is not yet set, and needs to be synced from 227 /// profile summary. Note that in case of missing profile 228 /// summary, threshold will be kept at "MAX", effectively 229 /// suppresses all remarks output. 232 /// Set the minimum hotness value a diagnostic needs in order to be 233 /// included in optimization diagnostics. 236 /// Return if hotness threshold is requested from PSI. 239 /// The "main remark streamer" used by all the specialized remark streamers. 240 /// This streamer keeps generic remark metadata in memory throughout the life 241 /// of the LLVMContext. This metadata may be emitted in a section in object 242 /// files depending on the format requirements. 244 /// All specialized remark streamers should convert remarks to 245 /// llvm::remarks::Remark and emit them through this streamer. 249 std::unique_ptr<remarks::RemarkStreamer> MainRemarkStreamer);
251 /// The "LLVM remark streamer" used by LLVM to serialize remark diagnostics 252 /// comming from IR and MIR passes. 254 /// If it does not exist, diagnostics are not saved in a file but only emitted 255 /// via the diagnostic handler. 261 /// Get the prefix that should be printed in front of a diagnostic of 262 /// the given \p Severity 265 /// Report a message to the currently installed diagnostic handler. 267 /// This function returns, in particular in the case of error reporting 268 /// (DI.Severity == \a DS_Error), so the caller should leave the compilation 269 /// process in a self-consistent state, even though the generated code 270 /// need not be correct. 272 /// The diagnostic message will be implicitly prefixed with a severity keyword 273 /// according to \p DI.getSeverity(), i.e., "error: " for \a DS_Error, 274 /// "warning: " for \a DS_Warning, and "note: " for \a DS_Note. 277 /// Registers a yield callback with the given context. 279 /// The yield callback function may be called by LLVM to transfer control back 280 /// to the client that invoked the LLVM compilation. This can be used to yield 281 /// control of the thread, or perform periodic work needed by the client. 282 /// There is no guaranteed frequency at which callbacks must occur; in fact, 283 /// the client is not guaranteed to ever receive this callback. It is at the 284 /// sole discretion of LLVM to do so and only if it can guarantee that 285 /// suspending the thread won't block any forward progress in other LLVM 286 /// contexts in the same process. 288 /// At a suspend point, the state of the current LLVM context is intentionally 289 /// undefined. No assumptions about it can or should be made. Only LLVM 290 /// context API calls that explicitly state that they can be used during a 291 /// yield callback are allowed to be used. Any other API calls into the 292 /// context are not supported until the yield callback function returns 293 /// control to LLVM. Other LLVM contexts are unaffected by this restriction. 296 /// Calls the yield callback (if applicable). 298 /// This transfers control of the current thread back to the client, which may 299 /// suspend the current thread. Only call this method when LLVM doesn't hold 300 /// any global mutex or cannot block the execution in another LLVM context. 303 /// emitError - Emit an error message to the currently installed error handler 304 /// with optional location information. This function returns, so code should 305 /// be prepared to drop the erroneous construct on the floor and "not crash". 306 /// The generated code need not be correct. The error message will be 307 /// implicitly prefixed with "error: " and should not end with a ".". 311 /// Access the object which can disable optional passes and individual 312 /// optimizations at compile time. 315 /// Set the object which can disable optional passes and individual 316 /// optimizations at compile time. 318 /// The lifetime of the object must be guaranteed to extend as long as the 319 /// LLVMContext is used by compilation. 322 /// Get or set the current "default" target CPU (target-cpu function 323 /// attribute). The intent is that compiler frontends will set this to a value 324 /// that reflects the attribute that a function would get "by default" without 325 /// any specific function attributes, and compiler passes will attach the 326 /// attribute to newly created functions that are not associated with a 327 /// particular function, such as global initializers. 328 /// Function::createWithDefaultAttr() will create functions with this 329 /// attribute. This function should only be called by passes that run at 330 /// compile time and not by the backend or LTO passes. 334 /// Similar to {get,set}DefaultTargetCPU() but for default target-features. 339// Module needs access to the add/removeModule methods. 342 /// addModule - Register a module as being instantiated in this context. If 343 /// the context is deleted, the module will be deleted as well. 346 /// removeModule - Unregister a module from this context. 347void removeModule(
Module *);
350// Create wrappers for C Binding types (see CBindingWrapping.h). 353/* Specialized opaque context conversions. 363}
// end namespace llvm 365#endif// LLVM_IR_LLVMCONTEXT_H #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)
Machine Check Debug Module
static void DiagHandler(const SMDiagnostic &Diag, void *Context)
This is the base abstract class for diagnostic reporting in the backend.
This is an important class for using LLVM in a threaded context.
void setMisExpectWarningRequested(bool Requested)
std::optional< StringRef > getSyncScopeName(SyncScope::ID Id) const
getSyncScopeName - Returns the name of a SyncScope::ID registered with LLVMContext,...
remarks::RemarkStreamer * getMainRemarkStreamer()
The "main remark streamer" used by all the specialized remark streamers.
uint32_t getOperandBundleTagID(StringRef Tag) const
getOperandBundleTagID - Maps a bundle tag to an integer ID.
void disableDebugTypeODRUniquing()
void setYieldCallback(YieldCallbackTy Callback, void *OpaqueHandle)
Registers a yield callback with the given context.
void deleteGC(const Function &Fn)
Remove the GC for a function.
const std::string & getGC(const Function &Fn)
Return the GC for a function.
DiagnosticHandler::DiagnosticHandlerTy getDiagnosticHandlerCallBack() const
getDiagnosticHandlerCallBack - Return the diagnostic handler call back set by setDiagnosticHandlerCal...
void setLLVMRemarkStreamer(std::unique_ptr< LLVMRemarkStreamer > RemarkStreamer)
unsigned getMDKindID(StringRef Name) const
getMDKindID - Return a unique non-zero ID for the specified metadata kind.
void emitError(const Instruction *I, const Twine &ErrorStr)
emitError - Emit an error message to the currently installed error handler with optional location inf...
static const char * getDiagnosticMessagePrefix(DiagnosticSeverity Severity)
Get the prefix that should be printed in front of a diagnostic of the given Severity.
void enableDebugTypeODRUniquing()
std::unique_ptr< DiagnosticHandler > getDiagnosticHandler()
getDiagnosticHandler - transfers ownership of DiagnosticHandler unique_ptr to caller.
void setDefaultTargetCPU(StringRef CPU)
bool getDiagnosticsHotnessRequested() const
Return if a code hotness metric should be included in optimization diagnostics.
bool getMisExpectWarningRequested() const
void yield()
Calls the yield callback (if applicable).
void setDiagnosticsHotnessThreshold(std::optional< uint64_t > Threshold)
Set the minimum hotness value a diagnostic needs in order to be included in optimization diagnostics.
void setMainRemarkStreamer(std::unique_ptr< remarks::RemarkStreamer > MainRemarkStreamer)
bool isDiagnosticsHotnessThresholdSetFromPSI() const
Return if hotness threshold is requested from PSI.
void setOptPassGate(OptPassGate &)
Set the object which can disable optional passes and individual optimizations at compile time.
StringMapEntry< uint32_t > * getOrInsertBundleTag(StringRef TagName) const
getOrInsertBundleTag - Returns the Tag to use for an operand bundle of name TagName.
LLVMContext & operator=(const LLVMContext &)=delete
void setDiagnosticsHotnessRequested(bool Requested)
Set if a code hotness metric should be included in optimization diagnostics.
void setGC(const Function &Fn, std::string GCName)
Define the GC for a function.
bool shouldDiscardValueNames() const
Return true if the Context runtime configuration is set to discard all value names.
void(*)(LLVMContext *Context, void *OpaqueHandle) YieldCallbackTy
Defines the type of a yield callback.
bool isODRUniquingDebugTypes() const
Whether there is a string map for uniquing debug info identifiers across the context.
unsigned generateMachineFunctionNum(Function &)
generateMachineFunctionNum - Get a unique number for MachineFunction that associated with the given F...
StringRef getDefaultTargetFeatures()
Similar to {get,set}DefaultTargetCPU() but for default target-features.
void setDiagnosticsMisExpectTolerance(std::optional< uint32_t > Tolerance)
LLVMContextImpl *const pImpl
LLVMContext(const LLVMContext &)=delete
void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
void getOperandBundleTags(SmallVectorImpl< StringRef > &Result) const
getOperandBundleTags - Populate client supplied SmallVector with the bundle tags registered in this L...
void setDiagnosticHandlerCallBack(DiagnosticHandler::DiagnosticHandlerTy DiagHandler, void *DiagContext=nullptr, bool RespectFilters=false)
setDiagnosticHandlerCallBack - This method sets a handler call back that is invoked when the backend ...
void setDiscardValueNames(bool Discard)
Set the Context runtime configuration to discard all value name (but GlobalValue).
@ OB_clang_arc_attachedcall
StringRef getDefaultTargetCPU()
Get or set the current "default" target CPU (target-cpu function attribute).
void getMDKindNames(SmallVectorImpl< StringRef > &Result) const
getMDKindNames - Populate client supplied SmallVector with the name for custom metadata IDs registere...
void * getDiagnosticContext() const
getDiagnosticContext - Return the diagnostic context set by setDiagnosticContext.
SyncScope::ID getOrInsertSyncScopeID(StringRef SSN)
getOrInsertSyncScopeID - Maps synchronization scope name to synchronization scope ID.
uint64_t getDiagnosticsHotnessThreshold() const
Return the minimum hotness value a diagnostic would need in order to be included in optimization diag...
void setDefaultTargetFeatures(StringRef Features)
const DiagnosticHandler * getDiagHandlerPtr() const
getDiagHandlerPtr - Returns const raw pointer of DiagnosticHandler set by setDiagnosticHandler.
void setDiagnosticHandler(std::unique_ptr< DiagnosticHandler > &&DH, bool RespectFilters=false)
setDiagnosticHandler - This method sets unique_ptr to object of DiagnosticHandler to provide custom d...
OptPassGate & getOptPassGate() const
Access the object which can disable optional passes and individual optimizations at compile time.
LLVMRemarkStreamer * getLLVMRemarkStreamer()
The "LLVM remark streamer" used by LLVM to serialize remark diagnostics comming from IR and MIR passe...
void getSyncScopeNames(SmallVectorImpl< StringRef > &SSNs) const
getSyncScopeNames - Populates client supplied SmallVector with synchronization scope names registered...
uint32_t getDiagnosticsMisExpectTolerance() const
Streamer for LLVM remarks which has logic for dealing with DiagnosticInfo objects.
A Module instance is used to store all the information related to an LLVM module.
Extensions to this class implement mechanisms to disable passes and individual optimizations at compi...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
StringRef - Represent a constant reference to a string, i.e.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
struct LLVMOpaqueContext * LLVMContextRef
The top-level container for all LLVM global data.
@ SingleThread
Synchronized with respect to signal handlers executing in the same thread.
@ System
Synchronized with respect to all concurrently executing threads.
This is an optimization pass for GlobalISel generic memory operations.
Attribute unwrap(LLVMAttributeRef Attr)
DiagnosticSeverity
Defines the different supported severity of a diagnostic.
LLVMAttributeRef wrap(Attribute Attr)
This is the base class for diagnostic handling in LLVM.
void(*)(const DiagnosticInfo *DI, void *Context) DiagnosticHandlerTy
