[#index]
= Global namespace
:mrdocs:

== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:llvm.adoc[`llvm`] 
| Top&hyphen;level LLVM library namespace&period;
|===


== Macros

[cols="1,4"]
|===
| Name| Description
| xref:BEGIN_REGISTER_VP_SDNODE.adoc[`BEGIN&lowbar;REGISTER&lowbar;VP&lowbar;SDNODE`] 
| Emit a Vector Predication SDNode enumerator from `VPSDID&period;`
| xref:CTXPROF_FUNCTION_DATA.adoc[`CTXPROF&lowbar;FUNCTION&lowbar;DATA`] 
| Declares the fields of FunctionData shared with LLVM&period;
| xref:DEBUG_WITH_TYPE.adoc[`DEBUG&lowbar;WITH&lowbar;TYPE`] 
| Execute `*VA&lowbar;ARGS*` when &hyphen;debug is enabled for `TYPE&period;`
| xref:DECLARE_TRANSPARENT_OPERAND_ACCESSORS.adoc[`DECLARE&lowbar;TRANSPARENT&lowbar;OPERAND&lowbar;ACCESSORS`] 
| Macro for generating in&hyphen;class operand accessor declarations&period; It should only be called in the public section of the interface&period;
| xref:DEFINE_TRANSPARENT_OPERAND_ACCESSORS.adoc[`DEFINE&lowbar;TRANSPARENT&lowbar;OPERAND&lowbar;ACCESSORS`] 
| Macro for generating out&hyphen;of&hyphen;class operand accessor definitions&period;
| xref:DEF_CONST.adoc[`DEF&lowbar;CONST`] 
| Expand to a ClassID enumerator for a Constant subclass&period;
| xref:DEF_INSTR.adoc[`DEF&lowbar;INSTR`] 
| Expand to a ClassID enumerator for an Instruction subclass&period;
| xref:DEF_USER.adoc[`DEF&lowbar;USER`] 
| Expand to a ClassID enumerator for a User subclass&period;
| xref:DEF_VALUE.adoc[`DEF&lowbar;VALUE`] 
| Expand to a ClassID enumerator for a Value subclass&period;
| xref:GET_R600_GPU_ENUM.adoc[`GET&lowbar;R600&lowbar;GPU&lowbar;ENUM`] 
| Not specified processor&period;
| xref:GET_RUNTIME_LIBCALL_ENUM.adoc[`GET&lowbar;RUNTIME&lowbar;LIBCALL&lowbar;ENUM`] 
| Include RuntimeLibcalls&period;inc to define RTLIB&colon;&colon;Libcall and LibcallImpl enums&period;
| xref:GET_RUNTIME_LIBCALL_FP_SELECTOR_DECLS.adoc[`GET&lowbar;RUNTIME&lowbar;LIBCALL&lowbar;FP&lowbar;SELECTOR&lowbar;DECLS`] 
| Declare floating&hyphen;point libcall selector overloads for each family&period;
| xref:HANDLE_BB_ADDR_MAP_FEATURE.adoc[`HANDLE&lowbar;BB&lowbar;ADDR&lowbar;MAP&lowbar;FEATURE`] 
| Expand a feature name into a bit&hyphen;index enumerator&period;
| xref:HANDLE_BINARY_INST-08.adoc[`HANDLE&lowbar;BINARY&lowbar;INST`] 
| Declare a Create helper that forwards to Create for one binary opcode&period;
| xref:HANDLE_BINARY_INST-04.adoc[`HANDLE&lowbar;BINARY&lowbar;INST`] 
| Declare a Create helper with an explicit insertion point for one binary opcode&period;
| xref:HANDLE_DIEVALUE.adoc[`HANDLE&lowbar;DIEVALUE`] 
| Expand to the DIEValue&colon;&colon;Type enumerator for payload type `T&period;`
| xref:HANDLE_DIEVALUE_SMALL.adoc[`HANDLE&lowbar;DIEVALUE&lowbar;SMALL`] 
| Return the stored small DIE value of type `DIE&num;&num;T&period;`
| xref:HANDLE_DW_LANG.adoc[`HANDLE&lowbar;DW&lowbar;LANG`] 
| Expand one DWARF source&hyphen;language enumerator from Dwarf&period;def&period;
| xref:HANDLE_DW_SECT.adoc[`HANDLE&lowbar;DW&lowbar;SECT`] 
| Expand one DWARF package&hyphen;file section kind enumerator from Dwarf&period;def&period;
| xref:HANDLE_OUTPUT_CONFIG_FLAG.adoc[`HANDLE&lowbar;OUTPUT&lowbar;CONFIG&lowbar;FLAG`] 
| Expand to a member initializer for one OutputConfig flag&period;
| xref:HANDLE_UNARY_INST-05.adoc[`HANDLE&lowbar;UNARY&lowbar;INST`] 
| Declare a Create helper that forwards to Create for one unary opcode&period;
| xref:HANDLE_UNARY_INST-00.adoc[`HANDLE&lowbar;UNARY&lowbar;INST`] 
| Declare a Create helper with an explicit insertion point for one unary opcode&period;
| xref:LAST_OTHER_INST.adoc[`LAST&lowbar;OTHER&lowbar;INST`] 
| Capture the maximum opcode number from Instruction&period;def as MaxOpcodes&period;
| xref:LDBG.adoc[`LDBG`] 
| output&period; The default level is 1, and is in increasing level of verbosity&period;
| xref:LDBG_GET_DEBUG_TYPE_STR__.adoc[`LDBG&lowbar;GET&lowbar;DEBUG&lowbar;TYPE&lowbar;STR&lowbar;&lowbar;`] 
| Helpers to get DEBUG&lowbar;TYPE as a StringRef, even when DEBUG&lowbar;TYPE is not defined (in which case it expands to &quot;DEBUG&lowbar;TYPE&quot;)
| xref:LDBG_GET_DEFAULT_TYPE_OR_LEVEL.adoc[`LDBG&lowbar;GET&lowbar;DEFAULT&lowbar;TYPE&lowbar;OR&lowbar;LEVEL`] 
| Provide the default level (&equals;1) or type (&equals;DEBUG&lowbar;TYPE) for a single argument&period;
| xref:LDBG_LEVEL_OR_TYPE.adoc[`LDBG&lowbar;LEVEL&lowbar;OR&lowbar;TYPE`] 
| Expand LDBG() when a single level&hyphen;or&hyphen;type argument is provided&period;
| xref:LDBG_OS.adoc[`LDBG&lowbar;OS`] 
| Invoke a callback with a prefixed debug `raw&lowbar;ostream`, like LDBG()&period;
| xref:LDBG_OS_IMPL.adoc[`LDBG&lowbar;OS&lowbar;IMPL`] 
| This macro is the core of the LDBG&lowbar;OS() macros&period; It is used to print the debug output with the given stream, level, type, file, and line number&period;
| xref:LDBG_STREAM.adoc[`LDBG&lowbar;STREAM`] 
| This macro expands to the stream to use for output, we use a macro to allow unit&hyphen;testing to override&period;
| xref:LDBG_STREAM_LEVEL_TYPE_AND_FILE.adoc[`LDBG&lowbar;STREAM&lowbar;LEVEL&lowbar;TYPE&lowbar;AND&lowbar;FILE`] 
| These macros are helpers to implement LDBG() with an increasing amount of optional arguments made explicit&period;
| xref:LDBG_STREAM_LEVEL_TYPE_FILE_AND_LINE.adoc[`LDBG&lowbar;STREAM&lowbar;LEVEL&lowbar;TYPE&lowbar;FILE&lowbar;AND&lowbar;LINE`] 
| This macro is the core of the LDBG() implementation&period; It is used to print the debug output with the given stream, level, type, file, and line number&period;
| xref:LDBG_TYPE_AND_LEVEL.adoc[`LDBG&lowbar;TYPE&lowbar;AND&lowbar;LEVEL`] 
| Expand LDBG() when both a debug type and a level are provided&period;
| xref:LLVM_DECLARE_ENUM_AS_BITMASK.adoc[`LLVM&lowbar;DECLARE&lowbar;ENUM&lowbar;AS&lowbar;BITMASK`] 
| LLVM&lowbar;DECLARE&lowbar;ENUM&lowbar;AS&lowbar;BITMASK can be used to declare an enum type as a bit set, so that bitwise operation on such enum does not require static&lowbar;cast&period;
| xref:LLVM_DECLARE_REGISTRY.adoc[`LLVM&lowbar;DECLARE&lowbar;REGISTRY`] 
| Helper macro to declare registry class&period;
| xref:LLVM_DECLARE_REGISTRY_EX.adoc[`LLVM&lowbar;DECLARE&lowbar;REGISTRY&lowbar;EX`] 
| Helper macro to declare a registry class with an explicit export annotation&period;
| xref:LLVM_DEFINE_REGISTRY.adoc[`LLVM&lowbar;DEFINE&lowbar;REGISTRY`] 
| Helper macro to define registry class&period;
| xref:LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE.adoc[`LLVM&lowbar;ENABLE&lowbar;BITMASK&lowbar;ENUMS&lowbar;IN&lowbar;NAMESPACE`] 
| LLVM&lowbar;ENABLE&lowbar;BITMASK&lowbar;ENUMS&lowbar;IN&lowbar;NAMESPACE() pulls the operator overloads used by LLVM&lowbar;MARK&lowbar;AS&lowbar;BITMASK&lowbar;ENUM into the current namespace&period;
| xref:LLVM_MARK_AS_BITMASK_ENUM.adoc[`LLVM&lowbar;MARK&lowbar;AS&lowbar;BITMASK&lowbar;ENUM`] 
| LLVM&lowbar;MARK&lowbar;AS&lowbar;BITMASK&lowbar;ENUM lets you opt in an individual enum type so you can perform bitwise operations on it without putting static&lowbar;cast everywhere&period;
| xref:LLVM_PLUGIN_API_VERSION.adoc[`LLVM&lowbar;PLUGIN&lowbar;API&lowbar;VERSION`] 
| macro LLVM&lowbar;PLUGIN&lowbar;API&lowbar;VERSION Identifies the API version understood by this plugin&period;
| xref:LLVM_YAML_IS_DOCUMENT_LIST_VECTOR.adoc[`LLVM&lowbar;YAML&lowbar;IS&lowbar;DOCUMENT&lowbar;LIST&lowbar;VECTOR`] 
| Utility for declaring that a std&colon;&colon;vector of a particular type should be considered a YAML document list&period;
| xref:LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR.adoc[`LLVM&lowbar;YAML&lowbar;IS&lowbar;FLOW&lowbar;SEQUENCE&lowbar;VECTOR`] 
| Utility for declaring that a std&colon;&colon;vector of a particular type should be considered a YAML flow sequence&period;
| xref:LLVM_YAML_IS_SEQUENCE_VECTOR.adoc[`LLVM&lowbar;YAML&lowbar;IS&lowbar;SEQUENCE&lowbar;VECTOR`] 
| Utility for declaring that a std&colon;&colon;vector of a particular type should be considered a YAML sequence&period;
| xref:LLVM_YAML_IS_STRING_MAP.adoc[`LLVM&lowbar;YAML&lowbar;IS&lowbar;STRING&lowbar;MAP`] 
| Utility for declaring that std&colon;&colon;map&lt;std&colon;&colon;string, &lowbar;type&gt; should be considered a YAML map&period;
| xref:LLVM_YAML_STRONG_TYPEDEF.adoc[`LLVM&lowbar;YAML&lowbar;STRONG&lowbar;TYPEDEF`] 
| Define a distinct strong typedef `&lowbar;type` over integral base `&lowbar;base&period;`
| xref:MAKE_CAS_HANDLE_CONSTRUCTOR.adoc[`MAKE&lowbar;CAS&lowbar;HANDLE&lowbar;CONSTRUCTOR`] 
| Allow ObjectStore implementations to create internal handles&period;
| xref:MIBEntryDef.adoc[`MIBEntryDef`] 
| Declare one MemInfoBlock schema field as a Meta enumerator&period;
| xref:NVPTX_GPU.adoc[`NVPTX&lowbar;GPU`] 
| Expand one NVPTX GPU enumerator from NVPTXTargetParser&period;def&period;
| xref:OMP_TYPE.adoc[`OMP&lowbar;TYPE`] 
| Declarations for OpenMP LLVM&hyphen;IR types from OpenMPKinds&period;def&period;
| xref:R_TYPE_SHIFT.adoc[`R&lowbar;TYPE&lowbar;SHIFT`] 
| Bit shift for the primary N64 relocation type field&period;
| xref:SUPPORTED_TENSOR_TYPES.adoc[`SUPPORTED&lowbar;TENSOR&lowbar;TYPES`] 
| X&hyphen;macro listing C element types paired with TensorType enumerator names&period;
|===


== Using Namespace Directives

[cols="1,4"]
|===
| Name| Description
| xref:llvm/support/endian.adoc[`endian`] 
| Helpers to read and write values with an explicit byte order&period;
| xref:llvm.adoc[`llvm`] 
| Top&hyphen;level LLVM library namespace&period;
|===



[.small]#Created with https://www.mrdocs.com[MrDocs]#
